{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bc7c411c",
   "metadata": {},
   "source": [
    "# DAY14"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f53bdfe",
   "metadata": {},
   "source": [
    "## 经典机器学习中的SHAP可解释分析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f735430b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 先运行之前预处理好的代码\n",
    "import pandas as pd\n",
    "import pandas as pd    #用于数据处理和分析，可处理表格数据。\n",
    "import numpy as np     #用于数值计算，提供了高效的数组操作。\n",
    "import matplotlib.pyplot as plt    #用于绘制各种类型的图表\n",
    "import seaborn as sns   #基于matplotlib的高级绘图库，能绘制更美观的统计图形。\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    " \n",
    " # 设置中文字体（解决中文显示问题）\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows系统常用黑体字体\n",
    "plt.rcParams['axes.unicode_minus'] = False    # 正常显示负号\n",
    "data = pd.read_csv('data.csv')    #读取数据\n",
    "\n",
    "\n",
    "# 先筛选字符串变量 \n",
    "discrete_features = data.select_dtypes(include=['object']).columns.tolist()\n",
    "# Home Ownership 标签编码\n",
    "home_ownership_mapping = {\n",
    "    'Own Home': 1,\n",
    "    'Rent': 2,\n",
    "    'Have Mortgage': 3,\n",
    "    'Home Mortgage': 4\n",
    "}\n",
    "data['Home Ownership'] = data['Home Ownership'].map(home_ownership_mapping)\n",
    "\n",
    "# Years in current job 标签编码\n",
    "years_in_job_mapping = {\n",
    "    '< 1 year': 1,\n",
    "    '1 year': 2,\n",
    "    '2 years': 3,\n",
    "    '3 years': 4,\n",
    "    '4 years': 5,\n",
    "    '5 years': 6,\n",
    "    '6 years': 7,\n",
    "    '7 years': 8,\n",
    "    '8 years': 9,\n",
    "    '9 years': 10,\n",
    "    '10+ years': 11\n",
    "}\n",
    "data['Years in current job'] = data['Years in current job'].map(years_in_job_mapping)\n",
    "\n",
    "# Purpose 独热编码，记得需要将bool类型转换为数值\n",
    "data = pd.get_dummies(data, columns=['Purpose'])\n",
    "data2 = pd.read_csv(\"data.csv\") # 重新读取数据，用来做列名对比\n",
    "list_final = [] # 新建一个空列表，用于存放独热编码后新增的特征名\n",
    "for i in data.columns:\n",
    "    if i not in data2.columns:\n",
    "       list_final.append(i) # 这里打印出来的就是独热编码后的特征名\n",
    "for i in list_final:\n",
    "    data[i] = data[i].astype(int) # 这里的i就是独热编码后的特征名\n",
    "\n",
    "\n",
    "\n",
    "# Term 0 - 1 映射\n",
    "term_mapping = {\n",
    "    'Short Term': 0,\n",
    "    'Long Term': 1\n",
    "}\n",
    "data['Term'] = data['Term'].map(term_mapping)\n",
    "data.rename(columns={'Term': 'Long Term'}, inplace=True) # 重命名列\n",
    "continuous_features = data.select_dtypes(include=['int64', 'float64']).columns.tolist()  #把筛选出来的列名转换成列表\n",
    " \n",
    " # 连续特征用中位数补全\n",
    "for feature in continuous_features:     \n",
    "    mode_value = data[feature].mode()[0]            #获取该列的众数。\n",
    "    data[feature].fillna(mode_value, inplace=True)          #用众数填充该列的缺失值，inplace=True表示直接在原数据上修改。\n",
    "\n",
    "# 最开始也说了 很多调参函数自带交叉验证，甚至是必选的参数，你如果想要不交叉反而实现起来会麻烦很多\n",
    "# 所以这里我们还是只划分一次数据集\n",
    "from sklearn.model_selection import train_test_split\n",
    "X = data.drop(['Credit Default'], axis=1)  # 特征，axis=1表示按列删除\n",
    "y = data['Credit Default'] # 标签\n",
    "# 按照8:2划分训练集和测试集\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  # 80%训练集，20%测试集\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "05b836c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 1. 默认参数随机森林 (训练集 -> 测试集) ---\n",
      "训练与预测耗时: 0.9542 秒\n",
      "\n",
      "默认随机森林 在测试集上的分类报告：\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.77      0.97      0.86      1059\n",
      "           1       0.79      0.30      0.43       441\n",
      "\n",
      "    accuracy                           0.77      1500\n",
      "   macro avg       0.78      0.63      0.64      1500\n",
      "weighted avg       0.77      0.77      0.73      1500\n",
      "\n",
      "默认随机森林 在测试集上的混淆矩阵：\n",
      "[[1023   36]\n",
      " [ 309  132]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from sklearn.ensemble import RandomForestClassifier #随机森林分类器\n",
    "\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # 用于评估分类器性能的指标\n",
    "from sklearn.metrics import classification_report, confusion_matrix #用于生成分类报告和混淆矩阵\n",
    "import warnings #用于忽略警告信息\n",
    "warnings.filterwarnings(\"ignore\") # 忽略所有警告信息\n",
    "# --- 1. 默认参数的随机森林 ---\n",
    "# 评估基准模型，这里确实不需要验证集\n",
    "print(\"--- 1. 默认参数随机森林 (训练集 -> 测试集) ---\")\n",
    "import time # 这里介绍一个新的库，time库，主要用于时间相关的操作，因为调参需要很长时间，记录下会帮助后人知道大概的时长\n",
    "start_time = time.time() # 记录开始时间\n",
    "rf_model = RandomForestClassifier(random_state=42)\n",
    "rf_model.fit(X_train, y_train) # 在训练集上训练\n",
    "rf_pred = rf_model.predict(X_test) # 在测试集上预测\n",
    "end_time = time.time() # 记录结束时间\n",
    "\n",
    "print(f\"训练与预测耗时: {end_time - start_time:.4f} 秒\")\n",
    "print(\"\\n默认随机森林 在测试集上的分类报告：\")\n",
    "print(classification_report(y_test, rf_pred))\n",
    "print(\"默认随机森林 在测试集上的混淆矩阵：\")\n",
    "print(confusion_matrix(y_test, rf_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8a695ce",
   "metadata": {},
   "source": [
    "## SHAP 原理简介\n",
    "\n",
    "**目标：** 理解复杂机器学习模型（尤其是“黑箱”模型，如随机森林、梯度提升树、神经网络等）**为什么**会对**特定输入**做出**特定预测**。 SHAP 提供了一种统一的方法来解释模型的输出。\n",
    "\n",
    "**核心思想：合作博弈论中的 Shapley 值**\n",
    "\n",
    "SHAP (SHapley Additive exPlanations) 的核心基于博弈论中的 **Shapley 值**概念。想象一个合作游戏：\n",
    "\n",
    "1.  **玩家 (Players):** 模型的**特征 (Features)** 就是玩家。\n",
    "2.  **游戏 (Game):** 目标是预测某个样本的输出值。\n",
    "3.  **合作 (Coalition):** 不同的特征子集可以“合作”起来进行预测。\n",
    "4.  **奖励/价值 (Payout/Value):** 某个特征子集进行预测得到的值。\n",
    "5.  **目标：** 如何**公平地**将最终预测结果（相对于平均预测结果的“收益”）分配给每个参与的特征（玩家）？\n",
    "\n",
    "**Shapley 值的计算思路（概念上）：**\n",
    "\n",
    "为了计算一个特定特征（比如“特征 A”）对某个预测的贡献（它的 Shapley 值），SHAP 会考虑：\n",
    "\n",
    "1.  **所有可能的特征组合（子集/联盟）：** 从没有特征开始，到包含所有特征。\n",
    "2.  **特征 A 的边际贡献：** 对于**每一个**特征组合，比较“包含特征 A 的组合的预测值”与“不包含特征 A 但包含其他相同特征的组合的预测值”之间的**差异**。这个差异就是特征 A 在这个特定组合下的“边际贡献”。\n",
    "3.  **加权平均：** Shapley 值是该特征在**所有可能**的特征组合中边际贡献的**加权平均值**。权重确保了分配的公平性。\n",
    "\n",
    "**SHAP 的关键特性 (加性解释 - Additive Explanations):**\n",
    "\n",
    "SHAP 的一个重要特性是**加性 (Additive)**。这意味着：\n",
    "\n",
    "*   **基准值 (Base Value / Expected Value):** 这是模型在整个训练（或背景）数据集上的平均预测输出。可以理解为没有任何特征信息时的“默认”预测。\n",
    "*   **SHAP 值之和：** 对于**任何一个**样本的预测，**所有特征的 SHAP 值加起来，再加上基准值，就精确地等于该样本的模型预测值**。\n",
    "    ```\n",
    "    模型预测值(样本 X) = 基准值 + SHAP值(特征1) + SHAP值(特征2) + ... + SHAP值(特征N)\n",
    "    ```\n",
    "\n",
    "**为什么会生成 `shap_values` 数组？**\n",
    "\n",
    "根据上述原理，SHAP 需要为**每个样本的每个特征**计算一个贡献值（SHAP 值）：\n",
    "\n",
    "1.  **解释单个预测：** SHAP 的核心是解释**单个**预测结果。\n",
    "2.  **特征贡献：** 对于这个预测，我们需要知道**每个特征**是把它往“高”推了，还是往“低”推了（相对于基准值），以及推了多少。\n",
    "3.  **数值化：** 这个“推力”的大小和方向就是该特征对该样本预测的 **SHAP 值**。\n",
    "\n",
    "因此：\n",
    "\n",
    "*   **对于回归问题：**\n",
    "    *   模型只有一个输出。\n",
    "    *   对 `n_samples` 个样本中的**每一个**，计算 `n_features` 个特征各自的 SHAP 值。\n",
    "    *   这就自然形成了形状为 `(n_samples, n_features)` 的数组。 `shap_values[i, j]` 代表第 `i` 个样本的第 `j` 个特征对该样本预测值的贡献。\n",
    "\n",
    "*   **对于分类问题：**\n",
    "    *   模型通常为**每个类别**输出一个分数或概率。\n",
    "    *   SHAP 需要解释模型是如何得到**每个类别**的分数的。\n",
    "    *   因此，对 `n_samples` 个样本中的**每一个**，**分别为每个类别**计算 `n_features` 个特征的 SHAP 值。\n",
    "    *   最常见的组织方式是返回一个**列表**，列表长度等于类别数。列表的第 `k` 个元素是一个 `(n_samples, n_features)` 的数组，表示所有样本的所有特征对预测**类别 `k`** 的贡献。\n",
    "    *   `shap_values[k][i, j]` 代表第 `i` 个样本的第 `j` 个特征对该样本预测**类别 `k`** 的贡献。\n",
    "\n",
    "**总结:**\n",
    "\n",
    "SHAP 通过计算每个特征对单个预测（相对于平均预测）的边际贡献（Shapley 值），提供了一种将模型预测分解到每个特征上的方法。这种分解对于每个样本和每个特征（以及分类问题中的每个类别）都需要进行，因此生成了我们看到的 `shap_values` 数组结构。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f1be72c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import shap\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 初始化 SHAP 解释器\n",
    "explainer = shap.TreeExplainer(rf_model)\n",
    "\n",
    "# 计算 SHAP 值（基于测试集），这个shap_values是一个numpy数组，表示每个特征对每个样本的贡献值\n",
    "# 这里大家先知道这是个numpy数组即可，我们后面学习完numpy在来回头解读这个值\n",
    "shap_values = explainer.shap_values(X_test) # 这个计算耗时"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b48d34c",
   "metadata": {},
   "source": [
    "## shap的维度要求\n",
    "\n",
    "非常多的同学和我反映过代码跑不通，甚至换个电脑就不行了等玄学问题，本质都是由于没有搞清楚shap的维度要求，这里记录下，希望对大家有所帮助。\n",
    "\n",
    "分类问题和回归问题输出的shap_values的形状不同。\n",
    "\n",
    "- 分类问题：shap_values.shape =(n_samples, n_features, n_classes)\n",
    "- 回归问题：shap_values.shape = (n_samples, n_features)\n",
    "\n",
    "**数据维度的要求将是未来学习神经网络最重要的东西之一。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48bde9a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 9.07465700e-03, -9.07465700e-03],\n",
       "        [ 7.21456498e-03, -7.21456498e-03],\n",
       "        [ 4.55189444e-02, -4.55189444e-02],\n",
       "        ...,\n",
       "        [ 7.12857198e-05, -7.12857198e-05],\n",
       "        [ 4.67733508e-05, -4.67733508e-05],\n",
       "        [ 1.61298135e-04, -1.61298135e-04]],\n",
       "\n",
       "       [[-1.02606871e-02,  1.02606871e-02],\n",
       "        [ 1.85572634e-02, -1.85572634e-02],\n",
       "        [-1.64992848e-02,  1.64992848e-02],\n",
       "        ...,\n",
       "        [ 2.00070852e-04, -2.00070852e-04],\n",
       "        [ 5.11798841e-05, -5.11798841e-05],\n",
       "        [ 1.02827796e-04, -1.02827796e-04]],\n",
       "\n",
       "       [[ 3.21529115e-03, -3.21529115e-03],\n",
       "        [ 1.28184070e-02, -1.28184070e-02],\n",
       "        [ 1.02124914e-01, -1.02124914e-01],\n",
       "        ...,\n",
       "        [ 1.73012306e-04, -1.73012306e-04],\n",
       "        [ 4.74133256e-05, -4.74133256e-05],\n",
       "        [ 1.26753231e-04, -1.26753231e-04]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[ 1.15222741e-03, -1.15222741e-03],\n",
       "        [-1.71843266e-02,  1.71843266e-02],\n",
       "        [-3.04994337e-02,  3.04994337e-02],\n",
       "        ...,\n",
       "        [ 1.44859329e-04, -1.44859329e-04],\n",
       "        [ 1.80111014e-05, -1.80111014e-05],\n",
       "        [ 1.30107512e-04, -1.30107512e-04]],\n",
       "\n",
       "       [[ 1.29249120e-03, -1.29249120e-03],\n",
       "        [ 5.66948438e-03, -5.66948438e-03],\n",
       "        [ 2.49050264e-02, -2.49050264e-02],\n",
       "        ...,\n",
       "        [ 2.50590715e-06, -2.50590715e-06],\n",
       "        [ 4.68839113e-05, -4.68839113e-05],\n",
       "        [ 1.15002997e-05, -1.15002997e-05]],\n",
       "\n",
       "       [[-1.12640555e-03,  1.12640555e-03],\n",
       "        [ 1.42648293e-02, -1.42648293e-02],\n",
       "        [ 4.74790019e-02, -4.74790019e-02],\n",
       "        ...,\n",
       "        [ 6.19451775e-05, -6.19451775e-05],\n",
       "        [ 3.30996384e-05, -3.30996384e-05],\n",
       "        [ 4.45219920e-05, -4.45219920e-05]]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shap_values # 每一行代表一个样本，每一列代表一个特征，值表示该特征对该样本的预测结果的影响程度。正值表示该特征对预测结果有正向影响，负值表示负向影响。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c11ff698",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1500, 31, 2)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shap_values.shape # 第一维是样本数，第二维是特征数，第三维是类别数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "af0a98e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shap_values shape: (1500, 31, 2)\n",
      "shap_values[0] shape: (31, 2)\n",
      "shap_values[:, :, 0] shape: (1500, 31)\n",
      "X_test shape: (1500, 31)\n"
     ]
    }
   ],
   "source": [
    "print(\"shap_values shape:\", shap_values.shape)\n",
    "print(\"shap_values[0] shape:\", shap_values[0].shape)\n",
    "print(\"shap_values[:, :, 0] shape:\", shap_values[:, :, 0].shape)\n",
    "print(\"X_test shape:\", X_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "049176c0",
   "metadata": {},
   "source": [
    "上面这个输出有点玄学，不同电脑可能输出不同，中间的2个谁和x_test的尺寸一样就选谁"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "38fb9947",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 1. SHAP 特征重要性条形图 ---\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x950 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# --- 1. SHAP 特征重要性条形图 (Summary Plot - Bar) ---\n",
    "print(\"--- 1. SHAP 特征重要性条形图 ---\")\n",
    "shap.summary_plot(shap_values[:, :, 0], X_test, plot_type=\"bar\",show=False)  #  这里的show=False表示不直接显示图形,这样可以继续用plt来修改元素，不然就直接输出了\n",
    "plt.title(\"SHAP Feature Importance (Bar Plot)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c4b03c7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 2. SHAP 特征重要性蜂巢图 ---\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAv0AAAIsCAYAAABhpBaeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAADRsklEQVR4nOzdd3wU1frH8c/spif0IAQChCZIL6EICAmCCgJSFAUvXeBHEwERULgUsVEFkSIqRbw2RKSp9KZUkaKA0qRIJwRSSNud3x8xC0sCJJCe7/u+5po5M3POmd0NeebsM2cM0zRNREREREQk27JkdAdERERERCRtKegXEREREcnmFPSLiIiIiGRzCvpFRERERLI5Bf0iIiIiItmcgn4RERERkWxOQb+IiIiISDanoF9EREREJJtT0C8iIpKDnTp1irCwsIzuRo4TFhbGyZMnM7obkoMo6BcREcmhrl27RrNmzVi+fHlGdyXHWb58Oc2aNePatWsZ3RXJIRT0i0i2Ehsby6hRoyhWrBheXl40a9aM06dPO7YHBATQv39/p2O6du1KtWrVnMpsNhv58uWje/fuidowDMOxeHp6UqtWLX788cdk93H+/PlOddy6zJ8/P0Xnm10kvCahoaEZ3ZUc5aWXXqJx48Z07NiRN998E6vVytWrV532GTlyJK6urom+DTAMg40bN9532xs3bsQwjLvu86Bt3EnXrl0dv3MWi4WSJUsyYsQIoqOjk9y3a9euqd6Hjh078vjjj9OzZ89Ur1skKQr6RSRbGTVqFPPmzWPq1Kl8/fXX/PXXX3Tu3DnF9ezevZvQ0FDWrFmT5Pb+/fuza9culi9fTo0aNXj66afZtWtXitrYsGEDu3btclpatmyZ4r7ezcaNG3PshURq27t3L++//35GdyPVrF69mr179zJp0iQAmjZtit1uZ/PmzU77bdq0ibp165IrVy6n8l27dlGzZs007WNatlGiRAl27drF1q1bee211/joo4949dVXU72dpUuXsnTp0iS3TZo0iT179rBu3bpUb1fkdi4Z3QERkdT06aefMnz4cJ599lkAoqOjefbZZ/n7778JCAhIdj1r1qzBzc2NM2fOcOjQIR555BGn7UWLFiUwMBCAJk2asGPHDj744AMWLlyY7DaqVatG3rx5k73//di4cSMbN25Mk5HKnCYh6H/llVcyuiupYuLEibz55pu4u7sDUKtWLfLmzcvGjRt55plnALhx4wY7d+7kjTfeSHR8wuc/LaVlGx4eHo7669WrR3R0NEOHDmXy5Mm4ubmlWjsJAX/r1q0TbXN3d2f8+PFMmjSJxx9/PNXaFEmKRvpFJNuw2WyEhoZy8eJFR9mTTz7Jli1bKFCgQIrqWrNmDS+++CIFChS442j/rcqXL8+xY8dS3GeRjBASEsKuXbscwT2A1WqlcePGTuk027ZtIyYmhqZNm2ZAL9NX+fLliYuLS/eba1u1asX27dsTpVWJpDYF/SKSbVitVp566ikmT57M6NGjuX79Oj4+PjRo0CBRasLdhIeHs23bNho3bkyjRo2SFfSfO3cOPz+/B+m+E7vdzrhx4yhWrBi5cuXiqaee4vjx4077fP7551SoUAEvLy/Kly/PF1984dgWFBSEYRiMHTuWTZs2JXnPQFL50gEBAU77JKxv3bqV4OBgKlWq5LT/yZMnadOmDbly5cLf35833niDuLi4VHkNEnK+P/zwQ/LmzUu9evX49ttveeihh3j44Yc5ceIE8+fPx8fHhw8++IBChQpRuHBhBg0a5JSbbZomEydOpFixYnh6evLUU09x5MgRp7aCgoIYM2YMf/zxBy1btnT6BiYh/7tbt26cPHnS8VqOGTPGqY6pU6dSqlQpvLy8qFatGmvXrnVsGzNmDEFBQWzbto2aNWvi5eVFvXr1nN7Ta9eu0aNHD/LmzYuvry8dO3bkwoULTm3MmjWLMmXK4O3tTYMGDfjtt9/u67U9ePAglSpVwtPT06m8adOm7N+/33FvxaZNm8iTJw+1a9dOVMed8u3DwsLo2bMnefPmJV++fPTq1Yvw8PD76mdSbSR8Ls6fP0/Lli3x9vamTJkyKbqvJinnzp0DSNHv8YIFCyhbtiweHh7Uq1fPKcUvICAAwzBYsGABCxYscHxubj8fLy8vKlasyKFDhx6o/yL3oqBfRLKVefPm8fjjjzNu3DhKlCjBhAkTsNvtTvt8+OGHTjfPLliwwGn7pk2biI2NJSgoiKCgIDZu3EhsbGyS7V27do25c+eyZcsWnn/++VQ7jzfffJPJkyczbtw4li5dSlhYGE2aNHEE1Fu3bqVTp060a9eO1atX06FDBzp37uwIIufMmcOuXbvo2bMnNWrUeKB7Bn755Rdat25NrVq1eO211xzlMTExPPHEE1y5coXvvvuOt956i2nTpjF27NjUeRH+tXHjRmbOnMm2bdv473//y6JFi7h27RqLFy8GIDIykhkzZvDpp58yfvx4Pv74Y0aMGOE4fuzYsYwaNYpXXnmF77//nsjISBo2bMilS5ec2jl27BjBwcEUL16c8ePHO8rHjBnDrl27GD16NH5+fo7XslevXo59Pv/8c1599VUGDRrE6tWrqVevHs8++6zTza+nTp2iXbt29OjRg2+++YbTp087Xk/TNGnevDkbNmzg448/ZsGCBezbt8/pM7VgwQIGDhxI//79WbVqFb6+vjRu3JgrV66k+DW900Xq7Xn9GzdupHHjxlit1mTVa5omrVq14scff+Sjjz5izpw5/PDDD0mmtjyoZs2aUa5cOZYtW0aJEiXo3Llzot/15IiJiWHXrl289957NG/eHB8fn2QdN3/+fLp3787zzz/PihUr8PPzIzg4mMOHDwPxs/Ps2rWLFi1a0KJFC8fnJql7FPz8/Dh79myK+y6SIqaISDa0bt06s169eiZgtmnTxrTb7aZpmmaJEiXM559/3vztt98cS8uWLc2qVas6jh04cKBZunRp0zRN88CBAyZgbtq0ybEdcFrc3d3NN998M9l9mzdvXqI6APPSpUumaZrmjRs3TA8PD3PKlCmOY/bt22cC5vr1603TNM3ffvvNnD9/vmP72bNnTavVan711VdObY0ePdps1KhRkv0AzA0bNjiVlShRwpw3b57Tupubm7ljx45Ex8+fP990dXU1L1y44CgbNGiQWbx48WS9DrdKeE2uXr3qKNuwYYMJmP/8849pt9tNwPz8889N0zTNhg0bmqNHj3Yct3nzZsdx//3vf013d3czLi7OjIiIMD09Pc1Ro0Y5toeEhJh58+Y1x4wZ4yhr1KiRCZjffffdXftYokSJJLdt3rzZXLx4sWN9586dJuB43UaPHm0C5rfffuvYZ8KECWaZMmVM0zTNNWvWmIC5ZcsWx/a1a9eazz77rBkVFWWapmkGBASYL7/8stN5WK1W89NPP71jn+9k8eLFZtu2bZPcVqpUKXPQoEHmjRs3THd3d3PmzJlJ7pfU52f9+vUmYK5bty5R2caNG532TXh/7yapNhKOGzBggKMs4fU+c+bMXetL0KVLl0S/f02aNDH/+eefJPft0qVLovISJUqYnTp1cqzHxMSYpUuXNrt27Zqs42/Vpk0bc8mSJcnqu8j90o28IpItNW7cmODgYEaMGMF7773HkiVLaNeuHQC+vr5OU3Tmz5+fU6dOOdbXrFnDsWPHnKYTXLNmDQ0bNnSsv/zyy3Tr1g1PT09KlSqFq6trivu4efNmp7SjfPnyAXDkyBGioqIYPHgwgwcPdjrmyJEjBAcHU61aNa5fv86AAQPYunUrv//+O3a7ncjIyBT341ZJjZT26NEjyfSO/fv3ExsbS6FChRJti4mJSbWbIYsUKZLo51vfG4vFwqOPPupYr1WrFtHR0Zw5c4aLFy9y48YNGjdu7NieL18+x7cft2rWrNl9j0g/9thjrFixgp49e/Lzzz870odufT/8/Pxo27atY71gwYKOb5D27NmD1Wqlbt26ju2PP/644+bOsLAw/v77b6ZPn8706dOd2r49VSk57jay3LRpUzZu3MiOHTuIjo7miSeeSHa9u3fvxmq1Ov2uNGzYEFdXV3bt2kWjRo1S3Nc7uXXq3YIFCwLc8Ru5pAQEBPDdd99hsVgoXrx4im6qv3TpEidPnnT6XLm6utKoUSN27NiR7HoSpHZ6oEhSlN4jItnGypUrqVatmuNhN4Zh8Pbbb5M7d+5k5z6fPXuWgwcPMnXqVH777Td+++03nn76aVavXu20n5+fH9WqVaNcuXL3FfADVK5cmWrVqjmW21MoPv30U0cfEpaEoHHGjBk0adIEm83GsGHDOHr0KMWLF7+vfiSIi4vj/PnzicqTCvgT+Pv7J+rjb7/9hotL+o4pmabp+DnhwsVisTiV3+0YuPt53surr75Khw4dyJs3L2+++SZnzpxJtE/p0qWT3ReAqKgotm7dytWrVx3bx48fn+i1vv25E8lRqVIlDh48yPXr1xNta9q0Kfv27WPp0qWULFnyrv1OznkkZ9v9SEm/kuLu7k61atWoUqVKimfRSs3zvH79OocOHaJixYopOk4kpRT0i0i2kTdvXvbt28fevXsdZREREURFRVGiRIlk1ZFw026HDh0cwXizZs3YvXt3us2uUaZMGdzd3QkLC3P04ZFHHmHq1Kns378fgE8++YQOHTowc+ZMXnjhBby8vAgJCUlUl4eHxx1vrLVarU4j0d99912KRkorVarExYsX8ff3d/QzJCSEKVOmpNrNvMlht9vZsmWLY33Hjh14eXlRtGhRKlasiKenJxs2bHBsDw0NZc+ePdSqVStF7dzttfzkk08YPHgwEydOpF27dkl+Vu6WF1+9enVsNhvbtm1zlG3bto3HHnuMM2fOkDt3booXL86VK1ecLhQ//vhjtm7dmqLzAMidOzcNGzbkm2++SbTt8ccfxzAMZs6cmeJZe2rVqoXNZnN6P7Zu3UpsbGyKX+97Se59BmnhoYceonjx4k6fq7i4ODZv3pzoPO/2uQH45ptvCA4OTtFkAyL3Q0G/iGQbderUoVq1arz00kt8++23rFmzhvbt25M/f37HvP33smbNGsqWLeuUstKwYUPsdjvr169Pq6478fT05LXXXmPMmDHMmTOHzZs30717d7777jtKlSoFxKcobdu2jXXr1vH555/z2GOPERYWlii4qFOnDnv27GHJkiVs3ryZadOmObZVrVqV+fPnExsby/bt2xk+fDje3t7J7mfHjh0pXrw4bdq04YcffuD777/npZdeIjQ0NFXnOb8Xi8VC7969WbFiBR999BHvv/8+/fv3x2Kx4O3tzWuvvcaECROYOnUqq1evpnXr1nh4eNCvX78UtVOzZk0uXLjAJ598ws8//+x0k7ivry+rV69m8+bNzJ0715GWk9yLnyZNmlCnTh26dOnC4sWLWblyJa+88gr169d3jACPHj2amTNnMnHiRLZs2cLgwYOZM2dOsi9ob/fGG28wevToRE/azZs3L4GBgY4btVMi4eb3rl278s033/DNN9/QuXNnHn/8cYKCgu6rn5nV2LFjWbRoEf/9739Zt24dHTp04Ny5cwwfPtxpvzp16rB27Vp+/PFH1q9fz9y5cx3brl+/zujRo3n99dfTu/uSAynoF5Fsw8XFhZUrVxIYGEjfvn154YUXsFgsbNiwwZEvfzemabJ27VoaNGjgVF6pUiXy58+fKMUnLY0ePZqXX36ZN998k6eeeoqTJ0/y008/OR4wljBFZYsWLXj99dd56aWXCAwMTDTqGxwczBtvvEHfvn1p0qQJq1atcmybM2cOhw4dIn/+/PTv35+FCxfi6+ub7D66u7uzevVq8ufPz3PPPcdLL71EkyZN+Oyzz1LlNUiuhIukHj168Oqrr9KpUyenGYRGjx7N2LFjmTx5Mq1atcLd3Z3Nmzc78sCTq2zZssyZM4exY8cSFBTk9CC2BQsWOPLfJ02axLvvvouvr2+yR+EtFgs//PADjRo1okePHnTr1o1q1ao5cs4BunfvzqRJk5g9ezZPPPEEGzduZOnSpdSpUydF55Ggbt26tGzZkm7duiW6l6Np06ZYLBannPXkMAyDZcuW8cQTT9CzZ0969uzJk08+eccn0mZlXbt25ZNPPuF///sfzZs3559//mH9+vWUL1/eab8uXbrw3HPP0bFjR5o3b87OnTuB+G+ounfvTqtWrVL9WxCRpBhmaifZiYiIpJP58+fTv3//+54HPqeLiYnhySefpEuXLnpqczqbP38+8+bNczz9WyStKegXEZEsS0H/g7t+/Tre3t4ZmiOfE9lsNiIiIsidO3dGd0VyCAX9IiIiIiLZnHL6RURERESyOQX9IiIiIiK3mD9/fqLnN7zyyitOs1Bt3LjR6UGByfH3339jGAZ///33g3cyhRT0i4iIiIikUIMGDdLt+S2pQUG/iIiIiEgKubi4pPhpzhlJQb+IiIiISArdLb3n3XffdTy5ecSIETz88MO8+eabju1///03QUFBeHl5UbNmTY4cOZLm/XVJ8xZEREREbhMbG8u8efMA6NatG66urhncI8nWjLZJl5tL7njItWvXnEbyb9y4waOPPnrPpjZv3sz48ePZuHEjly5domXLlvz888+UKVPG8QTsHj168PbbbzNnzhxatmzJW2+9xfz581NyRimmoF9ERERE5Da5cuVi7969jvVx48Zx/Pjxex63c+dOKleuTGBgIAC+vr6cOHGCOnXqOIL+Xr168fzzzwPQrl07tm/fnvoncBsF/SIiIiKSzaVslh0Ai8VCQECAYz25D1KrUqUKb731FhcuXODKlStcuXKFypUrO+3z1FNPOX52d3cnPR6bpaBfRERERCSVlCxZkty5c1OsWDEMw2DcuHFUrFjRaZ88efKke78U9IuIiIhINpfykf77NWbMGJ5++mlefvll8uXLR8GCBdOt7bvR7D0iIiIiIqmkZ8+ezJs3j0cffRQ/Pz+8vLx44YUXiImJydB+GWZ6JBGJiIiI3EKz90i6Mp5Lutz8JtWbCggIYMiQIbRv3x6r1cqePXto1aoVe/bsoUKFCqneXnIpvUdEREREsrn0S+8ZMmQIM2fOZNiwYdjtdkqWLMm4ceN45JFH0q0PSVHQLyIiIiKSSgYMGMCAAQMyuhuJKKdfRERERCSbU9AvIiIiIpLNKb1HRERERLK59Mvpz6w00i8iIiIiks1ppF9EREREsjmN9GukX0REREQkm9NIv4iIiIhkcxrp10i/iIiIiEg2p5F+EREREcnmNNKvoF9EREREsjkF/UrvERERERHJ5jTSLyIiIiLZnEb6NdIvIiIiIpLNaaRfRERERLI18w4j/Tlp/F8j/SIiIiIi2ZyCfhERERGRbE5Bv4iIiIhINqecfhERERHJ5nJS9n7SNNIvIiIiIpLNaaRfREREMrWzYSa7zpv8eNzO1n9MahY28HY18HaN3/ZUSYO25Sx4uWo0V5Km2XsU9IuIiEgmY5omW8+YvLzOxslrcDXaefuhKyYWwwQg1g6fHzLp8aOd4OIGzUrB4yUsVCqoZAa5VU4K75OmoF9EREQyhevRJosO2vngVzuHQ+68n82MX24VY4c1J01++hvAxvPl7QyvY6VaIQV7IqCgX0RERDJYSBS8vjaW+b+Dad57/zux33Lst3+afHU4jqYBBsNrGwSXsGAYugDIufTeK+gXERGRDHHDdGVddAUGfwwRsalbd9y/FwDr/jZZ87dJ5YJ25jdzoUZhBX+SMxmm+SDX1CIiIiIpcyPWZMDaOBYdiCUGlzveZJkWOlYwePsxKyXyKPjPSWxG9yTLrean6dyTjKOgX0RERNJFrM3kk/12Rv9s52JkxvTB+m+s36ykwfynrRTwVPCfEyjoV9AvIiIiacxmN5n+q533f7Vz6npG9+Ymb1d4va6FgTUteLsp+M/ObEaPJMut5ifp3JOMo6BfRERE0kRkrMm8A3be2mbnXET8rZSZLegwgAKe0KeawRuPWnF3UfCfHSno1xN5s7Tjx4/Tt29f6tevz9NPP81nn32Wbm2PGTOGXr16JSpfvnw5gYGBad7+8uXLad++PfXq1ePZZ59l7dq1ad6miIgkz5EQO8M3xVFkZhwD1sYH/JD5An6I79PlG/DmNpPCH8bx9jYbITcyY0/lQZh3WHISBf1Z1Pnz5+nZsydnzpxhwIABBAUFMW3atHQN/JNSvXp1xo0bd8ftYWFhzJkzh7Nnz953G59//jnjxo2jZs2aDB48mFy5cvH666/z119/3XedIiLyYMJjTBb9YeeJr+N4+GMb7+0wuRadtQKr0GgYtdVO0ZlxdF8Vy5bT9ozukkiq0ZSdWdSsWbMIDw9n/vz5FCtWDIgPqOfNm8cLL7yAq6trhvTL398ff3//O24PCwtj7ty51KxZkyJFitxXGwsXLqRp06YMGzYMgGbNmvH000/z1VdfMWrUqPuqU0REUsY0Tf6+ButO2pm6286xUIi23bxRNquymxBlg3m/w7zfbVQoYOPFChaeL2+hdL4sfnI5mt47Bf1ZUGxsLBs2bKBOnTqOgB+gXr16rFq1imPHjlG+fPkM7GHaiYuL48qVKxQoUMBR5u3tTa9evXBzc8vAnuUQB07CT7/F/1XsEgyF8t7ctv9v+GkvPFEVTl2Bxb9AlRJgMcDFCp5u8PdFeKoGPPowrNsfv4RHw+VrcPgfyJcLCuaGFxtCdCxs/wvOXYViBaBZTfAvANcjITwKthyEv85CcV/4+zLsPQHli0C+3PB8PQgJx/z1WHy94TcwHvaD5jXh658hMhq6PQ5BlSCXZ3z/l2yDM1egSVXMxduwn7iCpUwhjJca3zzPzb/DjqPQoUH8+vYjYAOsxJ9ngVyYYVHw51noFoSRP1f8k4a+3Aq/HI5/zSqXgJ8Pg18+eOTOF8giKbHznJ3NZ0xalDIoXyDpL/EvR5r89LedI1dNXCzwVEmDo1cN/gmzcyoMivpALje4GGlQuSDkdjeItZkcDYUi3rD/MuR1N/nphMmW0/GBsT2JYfzbn5Sb1R28Ej/6/8YWO3ncoHMlg6DiFuoXNSjkrUAyq0jPaWEzK93ImwX9+eefvPjii3Tv3p2+ffs6yo8cOcKnn35K9+7dKVu2LGfPnqVVq1bMnj2bXLlyMXv2bPbt28eyZcvw8fFxHLd27Vo+/vhjTp8+TZEiRejcuTMtW7Z0bI+NjWX69OmsWrUKu91O27ZtuXz5MufOneOjjz5y6tvy5csZO3Ysu3fvdiqfM2cOc+fOTfJ8li1blqJR//bt23PlyhWmTZtGpUqV7rjfkiVLWLRoERcuXKB48eJ0796dpk2bJmp7wYIFnDt3joCAAPr27UuDBg0c21PrNcwWpq+Egbfc8OTmAn9MgzJ+8OUW6DA1+XWV8IWTl1Peh9S+C7BMYdg5Abp+AMt2AWBi+bcZEwMT090V49eJsHgbjPkq/jirJf5CJtrllk5F/XvUvyVennBqNkan9+GH3262WboQHLsAFgvM7QPdH0/FE5KcaNqvNl7ZEP+LYQDftzZoWcbqtM/xUJOan9kIjU6FBpOK9HMQq3HzwqZ4bni/sZU2DytbOrOLNXomWe5qJh2bZEf6lGZB586dA6BgwYJO5WXLluWdd96hbNmyTuWHDx+mR48eREREEBwcjIvLzS94Vq5cyYgRI6hcuTJDhw6lUqVKjB07luXLlzv2effdd/niiy94/PHH6dWrF+vWrWPDhg0p6nPjxo0ZN24cgwcPBqBbt26MGzeOcePGkS9fvhTVNXz4cOLi4ujWrRtDhw7lyJEjifZZsGABb7/9NmXKlGHw4MEUKVKEESNGsGnTJsc+X3zxBePGjSMgIIBXXnkFb29vBg8e7LRPggd9DbOFKcuc12Pi4P0V8T+//W3K6rqfgB9SPzn46HlYutMR8IPhGAuK/8nAiI6F+Rvgg1U3j7PZITp+r4S9E744dZRE3oBJy50DfogP+AHs9puvn8gDmLjr5i+GCby9I/EvyqKDZuoE/OL0TcaZMPjpRM6+CMo6jDssOYeC/izoxo0bAMlOZ5k1axbDhw/no48+YtSoUXh4eABgt9v54IMPaNasGf369SMoKIiBAwdSoUIFFi9eDMCVK1dYsWIFrVu35vXXX6dDhw7MmDGD6OiU/fUoW7YszZs3JygoCIA6derQvHlzmjdvjqenZ4rqqlGjBp9//jnNmjVj8+bNvPjii0ydOhW7Pf6Gq4T7Bpo0acKECRNo164dEydOxM/Pj6VLlwIQERHBrFmzCAoKYvLkybRv357Zs2dTpkwZpkyZkqqvYWYQEhLi9J6Fh4cTFhbmWI+JieHKlStOxyRcXDr2KZgrUb1mqULxP/gXSLQtqwjJZcX0TPhduv2Pd/x6VH4vKHD7+Se9r9NapeLgauWOisRf8N7P+3H7+vnz57n1i9vUeM/VRtZoo7C3UzHFcyduo2jiX19JBbfev5DdPlfp2YakD+X0Z0GGEf+vTEKQmyAyMpLTp0/j7++Pt/fNvwL169enRYsWieo5efIkly9fZtWqVaxatcppm5eXFwAHDx7EZrPRuHFjxzZ/f3+qVq2aaudzP/z9/Rk3bhzdu3fnnXfe4fPPP8fNzY1+/fpx4MABoqKinM7ZYrE4jbzv37+fyMhIWrVq5SizWq20atWKSZMmcerUKYoXL+7Y9iCvYWaQP39+p/VbU5Mg/gLy1vskAPz8/Jz3+WIIvDgV9pyIHxx5shrGoH9TmD57BYJGwZFzUDQfXLwen3dvGM5/Fe0mFPOFAc1h4vdwMTTp0Xt3l/j0lxsx8esGUCA3VPCHqBg4fQXOX73zyL+PB2Bght9wKjZcrBBnu7nPyGfJ/2wjyJ0HOkyJz/XPnwvz/DWwm5iGFaNNLTxebQPtG0DQf+HS9fh7Eorkhx//gBg7WEywGJj58sOVCIiOg3aPYrzYAArlgmfehRvRULQAvNYa5q6ND/jn9r3v9+P29cKFCzutp8Z7rjayRhtLnrHS5Gsbp8Kgsi/MaWpN1Ea3Sga/XYAFf0Bk7L/He0NELITF3szYcbHE34bi4QL53OO334iL3xZjB0zQfDbxrAbE2cHt3+v67Pa5Ss820oNy+hX0Z0l58+YF4Nq1a07l+/btY8CAAcyaNYtatWo5yp955pkk60k4vnfv3lSpUsVpW8KFRcLV/O2/9L6+vly+fJ8pGg8gPDycy5cvU7RoUVxdXQkICODDDz+kV69e/O9//6N3796O87r9H6FbhYaGAvHncauE9ZCQEKeg/0Few2yjjB/smJD0tgK54MD7KatvSNKvaWpK9jvwRDW4sjDRcU7Hl/aD03fP/UyyvSZVIeIL57IBTye3ZyL3VDy3wV8v3f3PucUwmNHEhRlNHry993bYGL7JHp8qYOScFP9bbykq7A2Nihk08DdoX05JE5I1KOjPgkqXLg3A0aNHncovXIjPFb49kHV3d0+ynjx58gDxAX2dOnWc6rl48SJ2u90xWp0QJCe4evXq/Z/AA/jll194/fXXWbBgARUrVgTAxcWFhg0bsn//fkJDQx3ndfvXjcuWLeO3335j9OjRjgun2y9cEtZvv8/gQV5Di0V/EEQk+3ittoUnAyxsOGVn/SmTDSdNIuKcb3DNblwMaBoANQpZ6FXVoHge/bue9WSzgbj7oE9tFlSwYEEqV67Mli1bnALbTZs2kT9/fqcR6rspUaIEvr6+rF271im3bvz48YwYMQKLxcIjjzyCYRhON7eeP3+evXv33lffc+eOTzaNjIy8r+MTLni2bdvmVL5v3z5y585N/vz5qVy5Mu7u7qxcudJpn2+//ZY//vgDgCpVquDl5cWyZTdvTrXZbCxbtoyiRYum6msoIpKdGIZBtUIGg2pZWd7OhWuvuLCinZW+1Q3ye2R071KHy7/xYdm88GkzKxcHuLDqOVfGN7Qq4JcsSyP9WdTgwYPp3bs3ffr0oX379uzZs4ctW7YwaNAgrNa73Dh4C4vFQr9+/Rg7diz9+/cnODiYQ4cOsW3bNoYPHw5AoUKFePLJJx03pZYoUYKvv/76voNZHx8fKlWqxEcffURISAgRERFcvHiRQYMGJev40qVLExQUxNy5c7ly5QplypRh9+7dbNmyhb59+2KxWMiVKxcvvfQSH374IaZpEhgYyI4dO/jjjz8cTwv29vamT58+TJ48mSFDhlCnTh3WrFnD0aNHmThxYrJTc5LzGoqIZGdWi8HTpQ2eLm1hSmOTdSdNxmy1sfN8/NhqVhv9d7NAt8oGg2tZeTi/RoezC+X0a57+LG3fvn1Mnz6dQ4cOkT9/fl588UU6dOjg2H7rHPOBgYF3rOenn37i008/5fTp0/j5+dGpUydat27t2B4VFcW0adP48ccfsdvtNG/enPDwcC5cuJDsefpvdebMGd5991327t3ruHl2yJAhyT7viIgIpk+fzoYNG4iIiKBEiRI8//zzifLuFy9ezKJFi7h06RIlS5akR48eBAcHO+2zbNky5s+fz7lz5yhZsuRd5+l/kNdQRCSnORdu8sEeOzP22AmLyeje3J1BfHrSoFoWhta2UNBLAWJ2E230SbLc3ZyVzj3JOAr6RUREJM2ERZvM2GNj7C8mMbbUf9zGg7Aa8bPqvlbbwpBaFnK7K9jPrhT0K+gXERGRdBAVZzLrNzvjfrFzPSZjZ/1JCO37VjcYVc9KIW8F+9ldlNE3yXIPc2Y69yTj6G4UERERSXMeLvE3/578PxdG17P8G4Ckb+Sf8NiQNmVhd2crM5q6KOCXHENBv4iIiKSb3O4G/61v5WgPaOL2By7YnJ7hl5YeLQI7O1n5to0rNQorBMpZjDssOYdm7xEREZF0558bnvPaxRMev3Oi5AvM2Zf6T/tNeHZAQU94u6GFHlUs2e/BiSLJpMtcERERyTB5LDeY1hgOdLfSvBT4uMaXp0ZoXq+owY/PWbnQ34WXqloV8OdgJkaSS06ikX4RERHJcBV8Lax81kJEjMmXh02m/2pj/6X44N+SjKf9ulggzh4/z36pvDCvuZW6RTS2KZJAQb+IiIhkGt5uBj2qGHSvbLD8mMn+iyb7L5n88o/JP+FJH+PrCR0rWGheyqBRMQMPl5w1givJoc+Egn4RERHJdAzDoFUZg1ZlbpadDbOz8zwE5DbwduXfxSSPh0b0Re5FQb+IiIhkCUVyWWid6/ZSjeDKveW0/P2k6NJYRERERCSbU9AvIiIiIpLNKegXEREREcnmlNMvIiIiItmacvoV9IuIiIhItqegX+k9IiIiIiLZnEb6RURERCRbU3qPRvpFRERERLI9jfSLiIiISLamkX6N9IuIiIiIZHsK+kVEREREsjml94iIiEiq+eKQncV/2Tl6FY6EQpPi4OFiMONxg4e8NdYoklEU9IuIiMgD+/6Inbd22Nl13rl8+XEAk5XHTXpXNXn3MQM3FwX/kr6U06/0HhEREXkAcXaTMT/baP194oD/VpFxMPVXk9qf27kaZaZfB0UE0Ei/iIiI3Kdz4SY1PrNxPiL5x+y7BBXm2VjcIu36JZKYRvo10i8iIiIptvZvO9UWpizgT3A+App9B5fsuVK/YyJJMDGSXHISBf0iIiKSIp8esNN0sZ1LkfdfR1iMwXvhT3PSViD1OiYid6SgX0RERJIlKtZO82/j6PGTHYAHzcwPw5PJEc05df3B+yZyNxrpV9AvIiIiyXD4iknVhXZ+OJG69UbjSvA38HeoPXUrFhEnCvpFRETkjuLsJiO32qg4z8aRq2nTxplwqDjfzolQzeojacW4w5JzZPmg//jx4/Tt25f69evz9NNP89lnn2V0lzKFs2fPEhgYyFdffZXRXbkv3377LYGBgWzfvj2juyIikmN9+6edUnNtvLXdxM6Dp/PciYlBZBzU+dzGvgsa8RdJC1k66D9//jw9e/bkzJkzDBgwgKCgIKZNm5YtAv+wsDDmzJnD2bNnM7orGWLHjh1O/83scvr7JSLZh2ma/O+gjZoL43h2uZ3TYenX9uUbUP0zO9/8qcBfUpd5hyUnydLz9M+aNYvw8HDmz59PsWLFgPjga968ebzwwgu4urpmcA/vX1hYGHPnzqVmzZoUKVIko7uTrux2O7t37wayVtCfU98vEckejl41eWu7ndV/m5y9j2k4U0NCENZ+uZ3gvXYWt7KS3zNnpWCIpJUsG/THxsayYcMG6tSp4wj4AerVq8eqVas4duwY5cuXz8Aeyv06ePAg169f5+mnn2bVqlWEhISQP3/+jO6WiEim98s/NjosM7l4A/J7gLcr2P8d0vwnHOLM+MDaBcCA6FsH1BNia/Pfn2//7+2S2n6vY1Jgw2koOttGcHGDtxpYqF4oEwb/pgmvL4Jfj0OXIDh2gYPb/uFEjCtVL/2D/7UQuHIdrAbciIVY281jjfj/i3Z3xSUqBgOwuFog1u68T0qHoz1doHJJyO8DLlbY8RfciAEvd4iNje+HxYBSheG5emCzw9aDcOoylPEDH3cIiYByReDHPXDqCri7QLtHoWBucHOF6iWhff0HffXSVU6bqScpWTboP378OJGRkYkC+9KlS9O0aVOsVisAgYGBjB49mpYtWzr2mTNnDitWrGD58uVAfP57q1atmD17Nrly5WL27Nns27ePZcuW4ePjk+x9ANauXcvHH3/M6dOnKVKkCJ07d3ZqOzAwkJEjR+Lu7s6cOXO4cuUKNWrUYMyYMeTLl485c+Ywd+5cx/7/93//5/h52bJlaTKKvGzZMhYsWMC5c+cICAigb9++NGjQwLHdNE0WLlzIkiVLuHz5MkWLFqVXr140adIk2eeVEtu3b8fFxYUOHTqwcuVKduzYQbNmzQDo1asXvr6+GIbBxo0beeqpp6hbty4TJkzAy8uLqVOnUqpUqWSdV3I+G5nx/RIRSco/YSb1/3czQrzbaL0Nkg4m7ydYN5L4Odl13H3HKBv8cMJk3Skbu/9jpXLBTBa4tZ8Ei7fF/7xmHzdcXKkQF0uF5Bxrxv+fe1TMzbJYexL7pNCNONh5JHF5eJTz+u+n4pdbHT1/8+f1B27+HBkDn21y3vfvi/Bam/vooGSULJvTf+7cOQAKFizoVF62bFneeecdypYtm+I6Dx8+TI8ePYiIiCA4OBgXl8TXRHfbZ+XKlYwYMYLKlSszdOhQKlWqxNixYx0BZIJNmzYxefJk2rZtS/v27dm+fTszZ84EoHHjxowbN47BgwcD0K1bN8aNG8e4ceNSHDwnxxdffMG4ceMICAjglVdewdvbm8GDB7Np081f7kWLFvHBBx9Qr149hg4dSunSpXnjjTc4ccJ53ra7nVdK7Ny5k3LlylGuXDny5MmTKMVn3bp1eHh40KBBA77//ntmzJhB9+7dCQkJ4bvvvkv2eSVXZnq/RETu5McT95EH/yATmKRj/B1jg/WnMmEG9oYDTquecbEZ1JEMsGpPRvcghTR7T5YN+m/cuAGAm5tbqtU5a9Yshg8fzkcffcSoUaPw8PBI9j52u50PPviAZs2a0a9fP4KCghg4cCAVKlRg8eLFTnX8/PPPzJgxg86dOztuQN63bx8Qf9HSvHlzgoKCAKhTpw7NmzenefPmeHp6ptq5AkRERDBr1iyCgoKYPHky7du3Z/bs2ZQpU4YpU6Y49gsJCaFTp04MGzaM1q1bM378eDw8PNi5c2eyzyu5IiMj2b9/P1WrVsUwDKpUqZKonRIlSjBq1CjatIkfYRgwYAAdOnSgbNmyhIWFJfu8kiuzvF8PIiQkhOjoaMd6eHg4YWE3786LiYnhypUrTsckXFjfaf38+fOY5s0/wmpDbaiNjG2jSq7rpOutiWnWVOKKDUwCC8cHaJnq/ahUwqksxmK941llO7XjB1dT4/1ID3o4VxZO7zGM+DfKbnce2YiMjOT06dP4+/vj7e2dojrr169PixYt7mufkydPcvnyZVatWsWqVauctnl5eTmtBwcHO6UllSxZkoMHD6aor6lh//79REZG0qpVK0eZ1WqlVatWTJo0iVOnTlG8eHEGDhyIaZocOXKEP/74gy1bthAREUFoaKhTfalxXnv27CEuLo5SpUoRGhpKmTJl2LJlC8ePH3ek7ZQrVw7A8S3L7evJPa/kyizv14O4/Z6IW1PSIP7iuUCBAk5lfn5+d10vXLiw2lAbaiMTtVGrZD7mPmFj4DqTGzZws4CrFTDAbofIOJL2oLHXA+X0J7Vj4gPfb2yhftH48kz1fvw4Cl6YAofOwDO1cPknhAMHQjhrePLIpX8oHnoFomLjzzOJ19kE7NwcgU21ENQ3N+T3js/XP3UFbLb4+wrsxH8YAPJ6w+NVwGKBnX9BSDg8lAc8XOPz/h/KDXtP/HsPAPEXOMV9wd0VapWBIc+k7LW6xe3vh6SPLBv0582bF4Br1645le/bt48BAwYwa9YsatWqleSxkZGRSZY/88wz92z3Tvsk9KN3795UqVLFaVvCBUqCChUq3HV7ekkI2n19fZ3KE9ZDQkIoXrw427dvZ/z48Zw/fx4/Pz+qV69O7ty5E9WXGueVMC//+PHjGT9+vFN5QtCfcL9GgtvXk3teSUnqs5FZ3i8RkXt5qaqVl6omf/+P99tZcsTO6r/Bdnv8fa/8/KS2pzin/+4sBvSpatC/eiZNTPBwg6XDHasWoPK/S3IYQA76biBD5bRR/aRk2aC/dOnSABw9etSp/MKFC0DigO9Wt+eiJ3B3d79nu3faJ0+ePED86EGdOnWc+nPx4kXsdjsWi8Vp34yWcOF0+fJlp/KE9Xz58hEeHs6wYcOoVq0a8+bNc9xDcevNrwlS47x27NhB8eLFGTZsmKNs2LBh7Nixg44dOyarjuSc150k9dnILO+XiEhqe6mKhZeqWIi1mWw8bTJ+u50d5yDadu9j01rpPLCirYXyBTJpwC+SxWTZ36SCBQtSuXJltmzZ4pRLtmnTJvLnz+8YyfXw8HDafuLEiTR5ymuJEiXw9fVl7dq1Tnlq48ePZ8SIEY6AP7kSRtLv9K1EaqhSpQpeXl4sW7bMUWaz2Vi2bBlFixalePHinDp1ioiICJ5++mlHwL97927HxVVqunjxIidOnKB+/frUqVPHsdSoUYM9e/YQG5u8G6SSc16Qup+N9Hi/RETSiqvVoGmAhU0vuHCln5X/PmpQyOvex6WVCQ0t/PWSVQG/SCrKsiP9AIMHD6Z379706dOH9u3bs2fPHrZs2cKgQYMcKR9VqlRhyZIl1KtXj9jYWMaMGUNAQIDjRuDUYrFY6NevH2PHjqV///4EBwdz6NAhtm3bxvDhw+9dwW18fHyoVKkSH330ESEhIURERHDx4kUGDRqUonp+/fVXbLbEQzatWrXCx8eHPn36MHnyZIYMGUKdOnVYs2YNR48eZeLEiRiGQdGiRXF3d2fBggVERERw9OhRli5dimEYTjdBpYaEWXpq167tVF67dm02b97M/v37k1WPt7f3Pc8LUvezkVrvl4hIRvN2Mxhb38qoR00m7rTz9g6T8HSalMbDCgubGzxXTsG+SGrL0kF/5cqVmTVrFtOnT2fKlCnkz5+fIUOG0KFDB8c+w4cPZ+zYsXTr1o2HHnqI7t27c/bsWVasWJHq/WnZsiVubm58+umnTJkyBT8/P0aOHEnr1q3vq77x48fz7rvvMmnSJMeNqCm1fv161q9fn6g8KCgIHx8fOnTogLe3N/Pnz+eXX36hZMmSTJkyxTGffZ48eXjvvfeYPn06EydOxN/fn9GjR/Pll1+ya9eu+zqvO9mxYwdWq5UaNWo4lSdcBKRkFP5e5wWp/9lIjfdLRCSzcLEYjKhrpV91kz5rbPzvcFq2ZuJiMdjSweqYpUckNSmnHwwzvedMEhERkSxnwyk7zy2zcyXq3vsmX/zdw7ndTJa3sdKwmEb4JW1cMkYmWV7QHJ9keXak3y4RERG5p+DiFg51t1A+/733TQkrNtY+iwJ+SVOap19Bv4iIiCRTQS8Lv3e18kbd1AiWTFyJo6fnBqoVTIXqROSuFPSLiIhIslktBuMbWJkWbMHzAe4MdLPAq94/UN31VOp1TuSOjDssOYeCfhEREUmxl2ta2PUfK14uKQ+dPF3gs2YQYL18751FUoF5hyUnUdAvIiIi96Wir8HZ/7PwYoXkh/3+PnCwm5U2ZdKwYyKSiIJ+ERERuW95PCx81tzKe48Z+HnfeT8L0Kwk/NbZQkCenJVWIRlPN/Jm8Xn6RUREJHN4rY6VwbVMxm+z8/0xk1PX4WoUlM8Pnq4w7ykLVQpqrFEkoyjoFxERkVThYjEYU9/KmPrx63a7HYtFgb5kvJw2qp8U/SaKiIhImlDAL5J5aKRfRERERLI5jfTrElxEREREJJvTSL+IiIiIZGvK6ddIv4iIiIhItqeRfhERERHJ1nLa03eToqBfRERERLI1pfcovUdEREREJNvTSL+IiIiIZHMa6ddIv4iIiIhINqeRfhERERHJ1pTTr5F+ERERyULCY0zOhtmx2e0Z3RWRLEUj/SIiIpLpbThlZ8gGO79dil/P6w6dK5q8H2zBMDSKK3enKTs10i8iIiKZ3FeH7Tzxzc2AHyA0GqbvMXlysY1Ym0b9Re5FQb+IiIhkWj//Y/LCCjtxdxiqXXMSOq2yY5oay5U7MzGSXHISBf0iIiKSKe0+b6fJ17Z77vfVn9D1B432i9yNgn4RERHJdGJsJs8vtxN175gfgIUHTZYdTebOkuNopF9Bv4iIiGRCTy22cfxayo5p973JuXCl+UhSjDssOYeCfhEREclUvj9iZ8PplB8XZ0LTb2zExCnVR+R2CvpFREQk0/j7mknb7+8/aP/jCvRdq6BfnJl3WHISBf0iIiKSKYRG2Wn6jY0HDdk/+R3G/aL8fpFb6eFccldnz56lVatWDB06lOeffz6ju5MsCX2+k2XLllGkSJF07JGIiNyLzW7y5GI7R0NTp74xv5hUKWindVmNbwo57qbdpCjol2wnX758jBs3DoC//vqLRYsW0a1bN0qWLOnYLiIimUecHRp/bWPn+dSr0wTafm9nXXsILq7AX0RBv2Q7np6eNG/eHIBcuXKxaNEi6tSpQ2BgYAb3TEQkE7HZIDIawm5AaCSER4Fhwo1YiLOBlzvk8wZvD3goD7i5pkk3wu3u1PgcDoekft0m0PhrO283MBlex4JhaLQ3p9JIv4J+ERGR9DFtBazdD6UKweq9cOw8uLtAsYJw+jLciAaLJT7Y9i8ALhY4eAZis2BuusUA04y/aHB1AZsdKhWHNnXh5acdu122+/B2eEsi0jgge32ryeifbfSvbjClsTVN2xLJrBT0S6pZtmwZCxYs4Ny5cwQEBNC3b18aNGjg2B4YGMjIkSNxd3dnzpw5XLlyhRo1ajBmzBinlJtFixbxxRdfEBkZSXBwMEWKFOGLL76gR48edOzYMVX7vGvXLmbOnMlff/1FwYIFadOmDZ06dcJiuflVcGBgIKNHj6ZGjRp8+OGH7Ny5k5kzZ/Lwww8zZswYzp49S7ly5Vi6dCnVq1fnP//5D+PGjSM2Npa3336bmjVrpmqfRSQL+mILvPJp4vJYGxw6c3PdZoNrkfFLVmb/d16UkIibZRv/iF8K5YHn4/82HI0rRASe6dKlWBOm7jGpVNBO98pK98lpNNKv2XsklXzxxReMGzeOgIAAXnnlFby9vRk8eDCbNm1y2m/Tpk1MnjyZtm3b0r59e7Zv387MmTMd29esWcO0adN46qmn6Nu3L7t27WL9+vUMHTo01YPn3bt3079/fwoVKsTQoUN57LHHmDFjBnPnzk2074ULF+jatSunTp2iUaNG5M6d27Ft3759nD17lubNm/PLL7/wxhtv0KFDBywWC1988UWq9vl+hYSEEB0d7VgPDw8nLCzMsR4TE8OVK1ecjjl37txd18+fP49p3pzwTG2oDbVx5zZu/HoEiRe241CGtv/HZTPbfK6ySxuSPgxTr7rcRXJm74mIiKBZs2bUrl2bSZMmAWCz2ejUqRMRERF8//33QPyIucViYeHChZQvXx6AYcOGceLECb7++msAJkyYwIEDB/jss88A+Oqrr5g+fTo///zzffV/y5YtDBo0iNmzZyfK6e/atSvu7u689957jrK33nqLffv2sXr1akdZYGAg7u7udO3alZ49ezrVMWbMGLZs2cKqVas4f/487dq1Y+DAgXTq1Ik33niDS5cu8dFHH91X30UkG/n1GDR4A6JiMronGcvTDba+BTVKExsbS+85m5kX1Shdu7C1g5X6RTXqm9McMSYmWV7WHJrOPck4Su+RB7Z//34iIyOdpsm0Wq20atWKSZMmcerUKYoXLw5AcHCwI+AHKFmyJAcPHnSsV6hQgRUrVrBnzx4KFSrEli1bKFq0aKr3+caNG/zxxx+YpkmTJk0SbQ8NDSVv3ryO9dKlS/PSSy8lWVdAQADu7u64usbf5Pbwww8DONZFRKhZGn6dCD8fhiolYM0+WLEbiuaHRhVhw+/wTwh4ukKR/FA1ADzdYdUe2HgAYpKZ1+/uCtGxaXoqd2QQn8v/cJH4m3+vhMXn8F8NB6sFAktDw4rwiL/jEKuRvg/RqlUYBfySYynolwcWGhoKgK+vr1N5wnpISIgj6K9QoYLTPrfPpFCjRg0AevXqBUCBAgWcRuJTy/Xr1zFNk2effZbg4OBE2728vJzWW7VqdcdZH6xW613XRUQAqFAsfgGo8zCMfO7mtpdbJH3MwDuUP4grYTBsIWw+GD9XZkRU/GISH7jb7PGLqxXc3cDFGn/DcaMK8GprqFYy1bpS1eUU1ax/s9cWkGp1JsVqQN9qBhMbKas559LFnoJ+eWAJI+KXL192Kk9Yv/Um3Tx58ty1rrfffttxA/C1a9coXbo0Hh4eqdthIHfu3BiGgY+PD3Xq1HGUX716lTNnzmC3O48+ubu7p3ofREQyRIFc8HG/jO4FAG6Gjf/zWs+J8t14b1faBGV53WF9ewvVCyngz8l0I69u5JVUUKVKFby8vFi2bJmjzGazsWzZMooWLeoY5U+Ov//+Gzc3N/z9/alYsWKaBPwQP5d/hQoV2LBhA7GxN78KnzVrFr17906TNkVEJDHDgDfrwdj6qR+U5XOHv3pYFfCLoJF+SaZff/0Vmy1xTmmrVq3w8fGhT58+TJ48mSFDhlCnTh3WrFnD0aNHmThxYooehvLII48wZ84cQkJCKFy4MN7e3hQpUoRy5cql5ukA0K9fPwYMGECPHj1o0aIFZ8+e5fvvv+fFF19Ms4sNERFJ2n8ftXItysaUX1NnfpE87nC4u5WCXhrhFY30g4J+Sab169ezfv36ROVBQUH4+PjQoUMHvL29mT9/Pr/88gslS5ZkypQpTvP0J8eTTz7JL7/8wtdff821a9ccFxq1a9fmww8/TNWnKdauXZvp06czc+ZM3n//fQoWLEifPn3o1KlTqrUhIiLJNznYyvWYOD4+8GD1uFthZRsLD3kr0BNJoCk7JdM4deoU7dq1o0OHDpQpUwar1UpUVBSbNm1ix44drFu3Dh8fn4zupoiIpILY2FjmzZsHQLdu3RwznkXHmRSbY+PSjfuv+9MnLXTTA7jkFoeNKUmWlzcHp3NPMo5G+iXTKFq0KN27d2fDhg0sXbqU6OhocuXKRfny5Zk8ebICfhGRHMDdxWDbi1bKfWLDdh/Dkq8GooBfJAkK+iXTsFqt9OnThz59+mR0V0REJAOVzmswup6F//6csnn8C3vDOw01bbIkppx+zd4jIiIimdCoRy00T8EjATxd4NdOVlwsCu5EkqKgX0RERDKlr1pYqFjg3vtZgFlNLBTxUcAvSTMxklxyEgX9IiIikin5uFvY8LwVr3skI89qatClkkIakbvRb4iIiIhkWgW9DP7uZcXPO/E2C/BVC4NeVZXHL3dn3mHJSRT0i4iISKZW0MvgeE8L7zwGhbzB1xPalIHtL1poX14Bv9yb0ns0e4+IiIhkAR4uFobXsTC8Tkb3RCRrUtAvIiIiItlaThvVT4rSe0REREREsjmN9IuIiIhItpbTbtpNikb6RURERESyOY30i4iIiEi2ppx+jfSLiIiIiGR7GukXERERkWxNI/0a6RcRERERyfY00i8iIiIi2Zpm71HQLyIiIiLZnNJ7lN4jIiIiIpLtKegXERGRB2a3mVw9GcGRBUcJOxiKaSqhQjIT4w5LzqH0HhEREblv9jg7B1aeY+t7hzBvxPLIvvP8bRhcLeZN4KRASrYLwDByVnAlkhlppF9ERETuy7VL0XzY8VfWTvgLW7QNAMOEOFcLURjsHfAzB2suwh4Rk8E9lZzOxEhyyUkU9IuIiEiKHVp3kend9xN+MRpIOlEib1QkPr+d5nzDz4g7F56+HRQRJwr6RUREJEUO/3SOlWMOEhd3731NIOy3qxwpv4C4i5Fp3jeRpJh3WHISBf0iIiKSbD8uvsTq1/dj2pMfMpmmge16HIfqLebGietp2DsRuRMF/SIiInJPdrvJ1Pf+YdmXl+47E/rkZYNNTX4i6sKNVO2byL0op19Bv4iIiNzD9WtxTHjnLL/ve7D0HBODqJAYDlVfSPT+i6nUOxFJDk3ZKSIiIne098ANpk09hxljYk2F+lzNOPzOneX6Y/Pw7Zqby9U8UlyHGR1H3L5zXF91EsIi8Dn4O+43QsFmh9AIKFoALoRCzVIQdgMeewTy5YKgiuCXDywa88xpclr+flIU9Gdi3377Le+88w4zZsygbt26Gd2dZNm9ezf/93//x7JlyyhSpMh917N8+XLGjh3Ll19+SZkyZVKxhyIikhxXrsYxdc4VjhyOwi0udQL+W0XesOIzKzfUjuNGUBiuD+e/47726zdg21HsMzZiOxZC5KEIovDgMr48xEncOAnYbx7w+6n4/+49Ef/fr3+5uc3dBYr5wnP1oEUgPFoO9ByBbM+ew1J5kqKgPxPbsWOH479ZJegXEZGsLfS6jf99F8pPWyKx2kxc06gdG1bAoOBOO8fK/Q+P2oXwrOtHntLu+DxkIXr3BWIvRWPbcBTPf07haQ/HhhsmFiD3LTWZpOjJqtFxcPQ8vLMkfimcFwJLw3udoUKxVD1HkcxEQX8mZbfb2b17N3Az+BcREUkLpmmy8fdo1u66we8/h2OYYKbTwKjl38SL6zuvcG1nCAU5QDQWruGLBRtWbBjY/t0rDTp1PhRW/Bq/PJQHejeFLsFQ2i/125IMk9Nu2k2Kgv5M6uDBg1y/fp2nn36aVatWERISQv78d/7qU0REJKX+PB/Hh+uj2HIoGvuVONxME38zY/OfLdixZdQ8IxevwZuL4xe/fPBSE/hPI3j4/tNVRTILBf2Z1Pbt23FxcaFDhw6sXLmSHTt20KxZM8f2wMBARo4cibu7O3PmzOHKlSvUqFGDMWPGkC9fvhTtM3r0aFq2bOmoe86cOaxYsYLly5cD8SNACxcuZMmSJVy+fJmiRYvSq1cvmjRpko6vyE3JOS+AJUuWsGjRIi5cuEDx4sXp3r07TZs2dapr2bJlLFiwgHPnzhEQEEDfvn1p0KABAL169cLX1xfDMNi4cSNPPfUUdevWZcKECXh5eTF16lRKlSoFwNq1a/n44485ffo0RYoUoXPnzk6vqYhIcv3yj0m3H21ExMJ7DS28WCE+AF530k7nVXbOR8QH5cVywfK2Vj7Zb+eD30xHkssLJe1cPXAdmw36t/Sm88o43K/FYJgmxr/RfKS3G1HuVjyvRuFmxufrF7pDf5JzAZDwoKOkxlLN2/a5ey33NxqbUK+RjH7caZtx+z7nrmK++Q28+Y3TvlHkJoKHyM0ZXIjC4u4K0bEARFsLEGt6Y7HH4UYkVs8YDF8vOBcCVgu8/iz8t33SJ7HrKHSZAdci4c3nofvjyT5/uTfdyKspOzOtnTt3Uq5cOcqVK0eePHmSTPHZtGkTkydPpm3btrRv357t27czc+bMFO9zL4sWLeKDDz6gXr16DB06lNKlS/PGG29w4sSJBzrHB3Gv81qwYAFvv/02ZcqUYfDgwRQpUoQRI0awadMmxz5ffPEF48aNIyAggFdeeQVvb28GDx7stM+6devw8PCgQYMGfP/998yYMYPu3bsTEhLCd999B8DKlSsZMWIElStXZujQoVSqVImxY8c6LppERFKi40obf12Ff8Kh2492LkfGhyvPr7BzNiL+dlUTOBUGzy+3Mf3fgJ9/y784YeGv6wbnrtoZ8VkYnlejsdpNLGZ8MGu3GlzP7+nYX+58qWEksXhyHSsxXMc/Poj6N+CPw4NYmw/YDey4EosX5g0TTl+GOHv8vQSjv4RfjyXdWOcP4NAZOBsCvebE/1ckFSnoz4QiIyPZv38/VatWxTAMqlSpws6dOxPt9/PPPzNjxgw6d+7MgAEDCAoKYt++fSne515CQkLo1KkTw4YNo3Xr1owfPx4PD48k+5Re7nZeYWFhzJ07lyZNmjBhwgTatWvHxIkT8fPzY+nSpQBEREQwa9YsgoKCmDx5Mu3bt2f27NmUKVOGKVOmONopUaIEo0aNok2bNgAMGDCADh06ULZsWcLCwrDb7XzwwQc0a9aMfv36ERQUxMCBA6lQoQKLFy9O99flTkJCQoiOjnash4eHExYW5liPiYnhypUrTsecO3furuvnz5/HNG+GDGpDbaiN1Gkj9OZuxNohIhbspsn16MQhemhUoiIA7Jb4MNZuJg5oTcPQbDUPyIKN2+czMm8Lqcxb/t9JaASQxOfq33IgfurRsBtZ7rN7v22kBz2cS+k9mdKePXuIi4ujVKlShIaGUqZMGbZs2cLx48cd6SQAwcHBlC9f3rFesmRJDh486FRXcva5l4EDB2KaJkeOHOGPP/5gy5YtREREEBoaen8nmArudl4HDhwgKiqKFi1aOLZbLBankff9+/cTGRlJq1atHGVWq5VWrVoxadIkTp2Kn+6tXLlyALi4uCS5fvLkSS5fvsyqVatYtWqVUx+9vLxS7Xwf1O33g/j4+Ditu7m5UaBAAacyPz+/u64XLlxYbagNtZEGbbxZ38LA9XZMoGcVgxJ54gOTsfWtvL7l5rSUFmBCI4MJO01+vyXmKuZhxzsqDoCna3nwySETz8hYRwqLS5wdj4iYWye4lBSIw5VocpGL88DN1CAXbhBLNHbcARMXYuK3Wi3xQTxAg0egUUUgic/VuOfh/+aC3Q6dG0G5otx+K3Fm/+zebxuSPhT0Z0Lbt28HYPz48YwfP96p/Nagv0KFCk7HGUmM3CRnn9tFRjo/cXH79u2MHz+e8+fP4+fnR/Xq1cmdO/cdjk4fdzuva9euAST6R+hWCRcsvr6+TuUJ6yEh8V+rWq3OIzm3rye01bt3b6pUqXLHPomIJNeAGhaeKWMQGQvlC9z8d2REHQsdyhucCLVzI86gWiGDIj4GL1YwWfO3nT+vmFR9yEIDfyvnQgpgs5uUeMiF4eF2XlkZg2Ex8bDZKZvfwN0w+Xx/fBqR3P0+AAO4UKoK7u5RWF9sgPViBG4WK9FlfXGv9BCWovlh+58YNjueFYpjt7hhbDyAUSQPRkV/KJof9v0N3u5QszTc9nfEoWdTaFYj/mFij/in2bnmVDltVD8pCvozoR07dlC8eHGGDRvmKBs2bBg7duygY8eOjrI8efLcs67k7HO7W3P1w8PDGTZsGNWqVWPevHkULFgQIMNvUr3beSVsu/3rxmXLlvHbb78xevRo8ubNC8Dly5ed9klYv/WG4OT0I3/+/NSpU8dRfuHCBS5evIjdbseiJz+KSAoVz510gBKQxyAgj3PQaDEMnixp5cmSN8v8fW/u4+tjYdHziZ9627ORyaLtUXy86QZnLt153D85oVJCvvvdjr/bPslv6d7t36sfd9tm3FZoPFoOejSh0G031Sb6Hrd0YcfxVoAat833H1z5Lq3fwv/Og1UiD0pBfyZz8eJFTpw4QYcOHZyCyBo1arBr1y5iY2NxdU29R6V4eHg4BccnTpxg+/btFCoUP4/DqVOniIiI4Omnn3YE/Lt37+bChQup1ofUVrlyZdzd3Vm5cqVjJh6If8LxjRs3AKhSpQpeXl4sW7aMhg0bAmCz2Vi2bBlFixalePHiyWqrRIkS+Pr6snbtWtq2besY3R8/fjwnTpxgxYoVqXx2IiKpw8vNoFdDT3o19OT8NRtTvw9n7x/RmJcytl/3nuUnDRlA9VLQ8THo9QTk8syonkgq003rCvoznYRZemrXru1UXrt2bTZv3sz+/fupWbNmqrVXpUoVlixZQr169YiNjWXMmDEEBAQ4guOiRYvi7u7OggULiIiI4OjRoyxduhTDMJxu7MlMcuXKxUsvvcSHH36IaZoEBgayY8cO/vjjD8aNGweAt7c3ffr0YfLkyQwZMoQ6deqwZs0ajh49ysSJE5OdmmOxWOjXrx9jx46lf//+BAcHc+jQIbZt28bw4cPT8jRFRFJN4TxW3uucB5vdZOXGCH5YHcY/l+LSpW1HTrwruJbPR5hvbXIXseDx21XiwmwYZ0JueVLY/U/reVcFcsHr7aBNHSh5p8lLJStTeo+C/kxnx44dWK1WatSo4VSecBGwffv2VA36hw8fztixY+nWrRsPPfQQ3bt35+zZs44R6jx58vDee+8xffp0Jk6ciL+/P6NHj+bLL79k165dqdaP1NatWzdy5crFokWL2LJlCyVLlmTixIkEBwc79unQoQPe3t7Mnz+fX375hZIlSzJlyhSnbweSo2XLlri5ufHpp58yZcoU/Pz8GDlyJK1bt07lsxIRSVtWi0Grxj60DPZm47ZIPv1fCDHhaTVGGl9veF5Xig8LxH9QNSzuN9OSEsbYzcgYYr/dD1sPYizZh3k5ksTjtinso2FAYCmoXALeeBZK6cZSyf4MM73nTBIREZEsIfKGna+XXGXdD6FYAavdjntMLI+cOE2UhxvhuX3wuBGNW2wsblExGHY7FfaeJ9rdyqXCXvhfC6FU6GWicCcOF07kKYAFGzWvHccOHA4swNFuHnTr2S3ZqatmWBSxX+8l5kw4V5adxS3uOr4n9+IaGxE/802cDdxdIdYGhfNCTBxULwle7lC/fPzNtPXKg8sdbqiVbGmT8WmS5Y3M7unck4yjkX4RERFJkpenha4vFuDhkm58vuAyUWEPPtFnnGHluqsXBaYEc9Rtb4qPN3J54NajLm6Az+gH7o5IjqFpRUREROSu6tXLxfh3i5Er94OPjhuuVvJv6Eru3tVToWciyWPeYclJFPSLiIjIPeXL58J70wJ4pNL9P3jQ13aD2jNq41tfN8uKpDcF/SIiIpIs7u4W+o4qTtHGtz8rNhksUPWnpyncvnTqd0zkHkyMJJecREG/iIiIJJvVaqHNhMpUbVM0WfsbgEcuKPHFk3jVK5K2nRPJhmJjYzl69CgxMTEP9JwkBf0iIiKSIoZh8MSrD9NxTFksLvGjpUnlR0e5uhLl5U7RHV3I1b58+nZS5BZZMac/MjKSLl26kCtXLsqXL8/hw4d59dVXqV69OufOnUtxfQr6RURE5L6Uq5OXLjOrEvBofqdyi80OpkmejhUpee5lXB/xzaAeimRdQ4YMYd26dUycOBG7PX7mrGHDhmG1WhkyZEiK69OUnSIiInLfCj/sQ7tJVTm1058rf14nbKkHJesVpEGrYniXzZPR3RMBsuYTeZcsWcLs2bNp06YNAwcOBKBSpUq89dZbdOzYMcX1KegXERGRB1a8dgGK1y4AnUpmdFdEsoXY2Fg8PT0Tld+4cYP7ebaugn4RERERyday4kh/y5Ytee211/Dzuzlb1u+//86oUaNo2bJliutTTr+IiIiIZGv2OyyZ2fvvv0+BAgWoXj3+QXaBgYFUrVqVAgUKMHXq1BTXp5F+EREREZFMJl++fGzYsIFNmzZx4MABID6nPygo6L7qU9AvIiIiItmaacl66T0JGjVqRKNGjR64HgX9IiIiIiKZTMmSJTGMO1+sHD9+PEX1KegXERERkWzNzIID/WPGjHH8bLfbOX36NIsXL+bixYu8+eabKa5PQb+IiIiISCbTpUuXRGWjRo3i5Zdf5tChQymuT7P3iIiIiEi2ZlqMJJesxjAM3n33Xb788ssUH6ugX0REREQkizh06BBRUVEpPk7pPSIiIiKSrZlZcJg7ODg40Y28kZGR7N27l969e6e4PgX9IiIiIiKZTFLz8bu4uDBy5EhatGiR4voU9IuIiEjGiLVT9OdoLi5Zgle5vOQaVBuXgHwZ3SvJhkxr1svfHz16dKrWp6BfRERE0l3oz+epNzASH9sNIjmJx0/7CJ2+CffO1fGZ1w7DkgXzMSTTsmfBm3ZTm36jREREJF2d/fwo+59eg8UWv34zHDPwWPgDpv8rEJHyGxVF5M4U9IuIiEi6ufT5Xxzo8fMdtpq4EoPl3FnM/F0wr1xP175J9mVakl5ykhx2uiIiIpJRrq48ydH/bLjrPjasgB17jCuxD72K/eTl9OmcSAazWCxYrdZkLymlnH4RERFJc9e2XeBwix+4NZnnziyYuIAdYgNG4vpTfyxPVErrLko2lhUexLVhw90viB+Ugn4RERFJU5E7z/Nb/RW4p+goOyYGFqKwPPlf6PgYfNIPPNzSqJciGatRo0ZpWr/Se0RERCTNXFp7jmN1vsJM1gh/Ygb2+B/+twXy/Afe+w5stlTsoeQEppH0kpMo6BcREZFUZ5omm2YfZ1fztVgSAvcHFRMHwz8Dzxdg3jowzdSpVyQHyLJB//LlywkMDOTpp592lMXFxfHoo48SGBjI7t2707TdrGLp0qW0bduWevXq0b59e1avXp3RXbqnixcvMnToUBo2bMgTTzzBBx98QFxcXLq0PWfOHFq2bJmofPfu3QQGBnL27Nl06YeISFZ2+mAYEzvsZffCv7HY0iAwj7VB9w/jR/6/3Zb69Uu2Y1qMJJes6u+//07xMVk+p//ChQuEh4fj4+PDyZMniY2NTdP2qlevzrhx49K0jdTy3Xff8dZbb1G9enWee+45fvjhB9544w08PDxo2LBhRncvSeHh4fTu3ZuwsDB69uxJeHg4CxYsIDIykmHDhmVYv0qWLMm4cePIl+/OT4qcM2cOQUFBlCtXLh17JiKSOVy6GMPPa66y94dLGJcisBkW8qZ1o2E34NmJUKYwzOgJT1ZP6xZF0k1ISAjDhg1j27ZtREZGOsrj4uI4d+5cimPeLB/0Axw7doyqVaty9OjRNG/L398ff3//NG/nQdlsNmbNmkWpUqX48MMPcXNzo2XLlrRr147Zs2dn2qD/888/5/Tp08yZM4eaNWsCYBgG8+bNo0ePHvj6+mZIvwoUKEDz5s3vus/cuXMpUqSIgn4RyfZi4uzsPRHHvkNRbDsaR9ixCPJficQ9zoZXTBye6d2ho+fhqTehfFGY1AWezjrfyEv6sGfBQf0+ffrw+++/07hxY2bPns3MmTM5duwYkyZNYsqUKSmuL1sE/UePHk23oD+rOHjwICEhITz33HO4ucXPdODj40ODBg34/vvvuXTpEgULFszgXib2008/UbJkSUfAD/Doo4/y8ccfs3//fho3bpyBvRMRybxOXzfxcoXQKJOlR2zkd4cahSxcvAFxNjsRMVA4l4Gvp4XfLtgIuRF/I+PfV02i7VDP3yA2Dpb8ZefAebgUBd6GiYth51qkndgoO7kiYwkxLNgMg6DrEVxzsWJiUCIyk9xYe/gfaPE2NjdXIkqXIa5ZIC55XHCNjMRy6BRmtTK4FM2Li7uJrWB+zHLFcDl3AUoXBr/8Gd17SUNZMZVn7dq1fPnllzRt2pSvv/6acuXK0bNnTyIjI/nxxx95+eWXU1Rflg/6q1atyrFjx4D44L9atWrs3bvXsd00TRYuXMiSJUu4fPkyRYsWpVevXjRp0gSI/4qkY8eOeHh4sGDBAgzD4Pz587Rr147WrVszdOhQp/aWL1/O2LFjE90z0KtXL3x9fTEMg40bN/LUU09Rt25dJkyYgJeXF1OnTqVUqVIEBgYyevRop7zxOXPmsGLFCpYvX57seu7lxIkTABQvXtypvFixYgCcPHmSggULEhgYSL9+/di9eze//fYbBQoUoGvXrrRr187puF27djFz5kz++usvChYsSJs2bejUqRMWS/xtIS1btqRZs2bUqFGDqVOn8s8//1C+fHnGjBmT7G9GwsLCOHXqFM2aNXMqL1q0KE2bNsXHx8dRlvA61qhRgw8//JCdO3cyc+ZMHn744WT32TRNPv30U77++msiIyN54oknyJs3b5J92717N//3f//HsmXLKFKkiKM84fOQYOzYsY712bNnZ6n7P0Qk6+qzxsbsfSbYTXBKobc7r5t2MOxgGPHT5Sfk2xsGM341iS80HMeExdgh1gQ7uMXZcY0zsbnF72M1TTLrbbTWmFhyHzoEhw45lZvLtjn6HP8IsFvM7Al9nP/+iGQkwzAw/71ZvW7duuzZs4eGDRvy7LPP3jP7IClZ9kbeBOXKlXOM8B87dixRasWiRYv44IMPqFevHkOHDqV06dK88cYbjqDYxcWF1157jYMHD7JmzRogPljz8fGhT58+KerLunXr8PDwcIymz5gxg+7duxMSEsJ3332XrvVcvXoVgDx58jiV58qVC4DQ0FBH2dy5cwF45ZVXKFmyJO+88w7Lly93bN+9ezf9+/enUKFCDB06lMcee4wZM2Y4jktw6NAhRowYQePGjenevTuHDh3i3XffTfZ5nzt3DiBRCo+vry/vvPMOtWvXdiq/cOECXbt25dSpUzRq1IjcuXOnqM+ffPIJs2bNokaNGvTv358///yTb775Jtn9hZv3eCTc59GmTRvHesmSJVNUl4jI/fgrxIwP+JPDMMBi3Hw+lmHELwk/Yybv2VlZlPHv/xI4BUHDF6V7fyT9ZMUpO5s0acIrr7ziSPFZuHAhp06dYv369U4xT3Jli6D/2LFjREREcO7cuURBf0hICJ06dWLYsGG0bt2a8ePH4+Hhwc6dOx37BAYG8tRTTzFz5kwOHz7MqlWrGDhwoNPIcnKUKFGCUaNG0aZNGwAGDBhAhw4dKFu2LGFhYelaT8LNHS4uzl/mJKxHR0c7yooVK8b06dNp374977//PmXKlGH+/PmO7TNmzKBatWoMHz6coKAgevToQVBQEN9++61T3du2bWP06NH07t2b7t270759e/bt25fs8064ScXdPXmPb5k3bx7t27dn0aJFjBo1isKFCye7z3FxcXz++efUqVOHd955h+eff57Zs2en+LHW/v7+NG/e3HHFXaVKFcd6gQIFUlRXWgoJCXF6z8PDw50+SzExMVy5csXpmISLsDutnz9/3jECoTbUhtrIuDY8XB4kTs+sY/Xpz+528+9lZn/Ps1sbkrTp06fj7+/Pr7/+Srdu3QgNDaVkyZK8+eab9O/fP8X1Zfn0nnLlynHt2jV27NiBaZpO6R0AAwcOxDRNjhw5wh9//MGWLVuIiIhwGumG+FHudu3a0a9fP6pVq3ZfX5skXHAkBNa3r6dnPQl5/LdPdZmwfmtg3bRpU0ewa7FYeOyxx5g3bx7h4eFYrVb++OMPTNN0pETdKjQ01JESU6FCBYKCghzbAgICuHHjRrL7nJB2Y7vtoSuxsbEcP36cQoUKOaXflC5dmpdeeilRPTdu3Lhnny9fvkxYWBjBwcGOch8fHxo2bMiePXuS3eesIn9+51zV2y9o3dzcEl2k+Pn53XX91osstaE21EbGtVE8N0xrbGHkVjsGBteibk/x+VdCkGUnfsjPJD4dyOmKwbhZlpDtk4UlfhkMbBhYif87Y8MFK3EYHq5Yvhzi2Cuzv+fZrY30YBpZ78P80EMPOU21vn//ftavX4+vry/16tVLcX1ZPugvXbo0Li4u/PTTTxQpUiTR1x3bt29n/PjxnD9/Hj8/P6pXr57kVyK+vr40bNiQH374gdatW99XX24fJU7uqPGt0zA9SD23Spha8vaLm+vXrzttv/1nuJkSFBkZiWmamKbJs88+6xQgJ/Dy8nL8XKFCBadtCUF8ciW0e+3aNafyf/75hxdffJFRo0bxzDPPOMpbtWqFkcQv8fXr1+/Z5/DwcCDxP2aZ8eZmEZF7GVDDwoAaqf/l/VsbYxi5JpUerJUBjBOzIeAhpzKXO/wsktn5+PjQqlWr+z4+y3/eXV1dKVWqFOvWrUsU4IWHhzNs2DCqVavGvHnzHAFdUg9fOnr0KKtXr8bPz4+PP/6YJk2aOEbL01rC/QWpKeFm39sf3nDq1CkgfhQ+weXLl532uXr1KoZh4OPjg2EYjp/r1KnjtM+ZM2ew22/+Mbif/LJb+fv74+HhkWgWposXLwKJc/3vlAaUO3fue/Y54WLl9guMkJCQBzoHEZHsZGgDV+r4W9hx2sbxSxYuXzD465rJ6UiItlgcXwhkOg0egbl9EgX8knNlxSk7a9euTYcOHXjuuedSZbr4LJ/TDzfTX27P5z916hQRERE8/fTTjoB/9+7dXLhwwWk/u93OW2+9Rbly5ZgzZw4XL17kk08+SZO+enh4OOW+nThxgu3bt6d6O4888ggFChRgzZo1jvz+iIgItm7dSvny5Z2+ilu9erUj7cdms7F582ZKly6Nl5cXnp6eVKhQgQ0bNjg9BGLWrFn07t07VftstVpp2LAhv//+u1Pgv2nTJlxcXKhUqVKy6klOnwMCAvDy8mLTpk2O7ZGRkWzZsuW++58nTx4iIiLu+3gRkczGzcWgSRkX3gh255P2Xnw/IA+HRuYl/O08rJ9RmNn98vFCkCeFS7hnjuD/2Ufh0nzY8haUz/zP1BG5m6CgID7++GMCAgIcE5LcHsOmRJYf6Yf4YH/58uWJgv6iRYvi7u7OggULiIiI4OjRoyxduhTDMJxuSlm8eDG///478+bNo0iRInTt2pVPPvmEJ598MlnTY6ZElSpVWLJkCfXq1SM2NpYxY8akOPc9OSwWC3379uXNN99k4MCBNG3alOXLlxMaGsro0aOd9r106RIvv/wyQUFBbN68mRMnTjB+/HjH9n79+jFgwAB69OhBixYtOHv2LN9//z0vvvgiHh4eqdrvvn37sn37dgYOHEinTp04efIk33zzDS+88EKimYjuJjl9fv7555k3bx4jR46kSpUqrFy5ksjIyPs+p9q1a/PFF1/g6upKXFwchw8fTvRai4hkF66uFmpXdKd2RXcgNzZbIf7cH8HGxRe4tDv6nsenqrZ14cOeUPjOT02XnC0rztM/YcIEJkyYwPHjx1m5ciXLly9n2LBh1K1blw4dOiR5X+PdZIuR/vLlywMkuok3T548vPfee8TGxjJx4kR27drF6NGjqVixIrt27QLiA94PP/yQFi1aOEaSO3fuTKFChXjrrbdS/e7y4cOHU7BgQbp168bIkSPp3Lkzjz/+eKq2keCZZ55h5MiRnD9/ngkTJhAeHs7bb79NgwYNnPbr1asX7u7uTJs2jZMnTzJy5Eieeuopx/batWszffp0DMPg/fffZ8OGDfTp04d+/fqlep/9/f355JNPKF26NDNmzGD9+vV0796dQYMGpaie5PS5T58+9OzZk507dzJt2jSKFCnCc889d999f+211yhfvjzTp09n+vTpie7VEBHJzqxWCxWq56LvW2V49avqBFTySfvR/wbl4dB0+PY1BfySbZUqVYoBAwbw008/ceDAATw8PO4r28IwNWdSjpbUw8JERERSw7FfrnCo6Y+UjLzIRSM3HmYsYHDd3QMXqw2/yFC8uEEcruQjFBPIxz9YiSAOL2x4YuUGLoQ7V1y2MHwxBGqWzojTkizof8W+TrK84+n26dyTlNu3bx8rVqxgxYoV7N+/n8cff5znn3+eF198MUX1ZIv0HhEREcl8StcrgN/vrTj2yAKISYUK/QvAkmFQq0wqVCY5SVacsrNPnz6sXLmS8+fPExwcTK9evWjTpo3T9OUpoaA/h9u9e3dGd0FERLIxr5K5eORkN7YV//K+An8Ta/wjA6b3gP7Nbz5BWCSbO3z4MK+//jrPPvtsohkM74eCfhEREUlTLoW8qXWqA3sKf5aC531ZMDCx58sH+6eAv3L25f5lxSk7N2zYkKr1ZYsbeUVERCRz8yjkRY2jL5C8mf3tGMRgCciD2+l3MBTwizwwBf0iIiKSLjxK56HSzrZ3He23YgNcsFYujMtf72B4J/0gRpGUMA0jySUnUdAvIiIi6SZXrYeotakZZpKhv0EU3sQ9XQ/2TgJXZSGLpBYF/SIiIpKu8tV5iDoHWhP+kBW4NeHHxJzWBZcVr4BFIYqkHtNIeslJdAktIiIi6c6jmA973/TE86ILT0VXwqNGYTxblMai0X2RNKHfLBEREckwNx5yJW+3eri6umZ0VyQbs+ew/P2k6LszEREREZFsTiP9IiIiIpKt5bT8/aRopF9EREREsrWsPGVnbGwsR48eJSYmhgsXLtx3PQr6RUREREQymcjISLp06UKuXLkoX748hw8f5tVXX6V69eqcO3cuxfUp6BcRERGRbC0rjvQPGTKEdevWMXHiROx2OwDDhg3DarUyZMiQFNenoF9EREREJJNZsmQJH3zwAQMGDHCUVapUibfeeouffvopxfXpRl4RERERyday4o28sbGxeHp6Jiq/ceMGpmkmccTdKegXEREREclkWrZsyWuvvYafn5+j7Pfff2fUqFG0bNkyxfUpvUdEREREsjXTYiS5ZGbvv/8+BQoUoHr16gAEBgZStWpVChQowNSpU1Ncn0b6RUREREQymXz58rFhwwY2bdrEgQMHgPic/qCgoPuqT0G/iIiIiGRrmX2mnrtp1KgRjRo1euB6lN4jIiIiGcJmN/hfeB2KfwRNvoojKtae0V0SybYU9IuIiEi6i4q1M+JKOzbFVuB8JKw7aVL2Yxs2e8pnJRG5l6yY058/f35mzZqVavUp6BcREZF0ZTdNqn5k55rp7VR+Jtxg8i6N9ksaMIykl0ysfv36HDx4MNXqU9AvIiIi6arlF9GcuJr0tmFbTC5HarRf5L333uPrr79m+fLlqVKfbuQVERGRdPPmhhhWHb37Pv+3xsbiZxSiSOrJ7Kk8SVm8eDFPPvkkrVu3plmzZtSuXdtp+3//+98U1WeY9/NILxEREZEU+upAHC98FQ1uVrCZ4GqJXyyAyb8pF/H7Hn3JSum8WS9Qk8xpVpUVSZb32d8inXuSfMHBwXfcZhgG69evT1F9uowWERGRNLf5hI0XvopJ9v7Nv7XxZw+FKZI6suKUnRs2bEjV+pTTLyIiImnq8EUbjebeSNExf12F6b/a0qhHIjmPLqFFREQkzZy9ZuORCeHxKT0pNHCDyVMl7TycX2OU8mBMI+t9hsaNG3fX7SnN6c96r4CwfPlyAgMDefrppx1lcXFxPProowQGBrJ79+5071NgYGCy7y7fvXs3gYGBnD17Nk36klB/YGAg9erVo23btkyZMoXQ0NAU1XP27NkMez1FRLKD01dtFB0X9kB1lPvUTmiUpvGUnGfDhg2OZd26dcyfP58xY8YwY8YMNm7cmOL6FPRnYRcuXCA8PByAkydPEhsbm2ZthYWFMWfOnDQL1NPCf/7zH1599VXKly/PF198QZcuXVIc+CdXVnx9RETS0vrfblB27LVUqavwTDuXIhX4y/3Lig/nujXo37RpE8ePH2fHjh089NBDvPLKKymuT0F/Fnfs2DEAjh69x/xnDygsLIy5c+dmqaC2Zs2atG3blrfffpuhQ4fyzz//8PHHH6dJW1nx9RERSQunz8XS/7/nGTwnlNSaHjDaDg/NtPPDcQX+krPVqlWLb7/9ltdffz3FxyqnP4s7evQoVatWTfOgP6t79tlnmT9/PmvWrOHVV1/N6O6IiKSfOBss3wWnLkMuD9h9DB7KA3XLQdgNCCgIR86BXz5su05im7cJS1wMLjGRcO0G+HiAfwFscQY3Dl7FiI4hClewWzCtVi5aCuEbe5lr+PJlwwb8UvZhXE0TXF1T9zxMaP6tHew2MM34AjtYDLDbwcMdKj5koUQe+OsylM0P7zW08OGvJmXyQpeqVlYdNynkDUHFNeaZ02TF2XvupFixYpw+fTrFxynoz8KqVq3qNNJfrVo19u7d67TPsmXLWLBgAefOnSMgIIC+ffvSoEEDx/bAwEBGjhyJu7s7c+bM4cqVK9SoUYMxY8aQL18+5syZw9y5cx37/9///Z9T3UWKFHFqb+XKlXz00UeEhIQ41ZMcW7du5ZVXXmH27NkEBgY6yt955x3Wrl3LTz/9hIvL/X1kLRYLVatWZc2aNVy6dImCBQsCsHbtWj7++GNOnz5NkSJF6Ny5My1btnQ69ty5c/Tq1Yvff/+dokWLMmDAABo2bAiQ4tdHRCTdtXkPVtzl3iQDMP+dJh9w+7c4YZ1rkZj/hGABfICTlMYdKMQFsEFuWyR/UYUzBQrwe0CptDyTeBYjvmcGYDexR8QBEGVY+PWiwa8XAdPk90vw3Z92cDHANHn951jCYuIDv7cbmox4NOU3Foukp4ULFyYqi4yM5H//+x+VK1dOcX0K+rOwcuXKOUb4jx07xmOPPeYU9H/xxRdMnjyZRo0a8fzzz7NmzRoGDx7MxIkTadSokWO/TZs2ceDAATp37sy1a9dYtGgRM2fO5I033qBx48YUK1aM0NBQpkyZQrdu3ShZsiRAomB+/fr1/P7773Tq1InQ0FCnepKjbt265M+fn9WrVzuCfpvNxoYNG3jiiSfuO+BPULhwYQAuX75MwYIFWblyJWPGjKF169a88MIL7Nu3j7FjxwI4Bf4TJ06kbt26vPzyy6xatYqhQ4cyZ84cqlWrlqLXR0Qk3V26dveAH0jIwfk3lHa4088X8SOQvY51V2zYyaCR1FubdLll9N7490rmlvWwuJur8w7YFfTnNFlwoH/06NGJylxcXKhatSoTJkxIcX36fisLK1euHMeOHSMiIoJz585Rrlw5x7aIiAhmzZpFUFAQkydPpn379syePZsyZcowZcoUp3p+/vlnZsyYQefOnRkwYABBQUHs27cPgLJly9K8eXOCgoIAqFOnDs2bN6d58+Z4eno61fPLL7/w4Ycf0rlzZ15++WWnepLDxcWFpk2bsn79euLi4v91/u233wgJCXGaqeh+ubu7AxAdHY3dbueDDz6gWbNm9OvXj6CgIAYOHEiFChVYvHix03EVK1ZkwoQJvPDCC8yePRtvb28WLFgApOz1yUghISFER0c71sPDwwkLuzmjRkxMDFeuXHE65ty5c3ddP3/+PLc+0FttqA21kQnbsNihYG6SKzk5+J7cIAp3x7odAzMzhBP2W3pvJnEmtxSV8InLvu95FmwjPZiGkeSSmZ04cSLRcuTIERYvXkypUin/Vk0j/VlYuXLluHbtGjt27MA0TR5++GHHtv379xMZGUmrVq0cZVarlVatWjFp0iROnTpF8eLFgfjHPJcvX96xX8mSJTl48GCK+/P444879aFUqVIcOnQoRXU0a9aMr776ip07d1KvXj3Wrl1L8eLFqVSpUor7c7uEf7Q8PDw4efIkly9fZtWqVaxatcppPy8vL6f15s2bO22rU6cOu3bteuD+pKf8+fM7rfv4+Ditu7m5UaBAAacyPz+/u64nfHOiNtSG2sjEbfgAP46CEZ/DkbPxwfDlMPByh/JFwdUKBXLBxWvg6kLM7nO4Xr2CiR0LpmNw1ARiccOOC0X4hzMUpiAhuBHDDVwpxFnOkYf0828+UpwdrP/20maCxcRiic/xd7FA0xKw/ZydfG4mr9a18u1fUMgbpjb2wN39ZsCXrd7zLNiGpA8F/VlY6dKlcXFx4aeffqJIkSLkzn1zNCdhakpfX1+nYxLWQ0JCHEF/hQoVnPYx7vPKNzXqqVSpEsWLF2f16tXUrVuXDRs28Nxzz91Xf2536dIlIP41OHPmDAC9e/emSpUqTvvd3u/bX8P8+fM7jXKIiGRqNUrDT8l7iI/7HcpvzfX3AG4NAxOGSepdszH/5VP31cWU2vkfF2r5pfxvTJ8aadAZyRIy+/ScSRk3bhy9evVKdJE0ceJEPvvsM/bv35+i+jLB93Fyv1xdXSlVqhTr1q1zSu0ByJs3LxCfv36rhPVb883z5Emd0ZnUqqdZs2Zs3LiR7du3c+XKFZo1a5Yq9e7bt49ChQrh6+vr6Gv+/PmpU6eOYwkICMDT0xO7/ea0cCEhIU71XLt2DW9v71Tpk4hIdpE7j5VPZhanYU2PVJuq04kBtQvDXy9Z7ivgF8lqxo4dm+RU4PXr1+fPP/9McX0K+rO4hGD/9qC/SpUqeHl5sWzZMkeZzWZj2bJlFC1a1DHKn1wJ3yJERkY+YI/vrVmzZoSHhzNhwgSqVq1K0aJFH7jOpUuXcu7cOUe6U4kSJfD19WXt2rVOeYXjx49nxIgRWCw3fzV++uknx89RUVHs2LGDihUrOtWfnq+PiEhm5e1tZUQfXz55rzBViqXujbIzHrewo5MLZfMpdJGUy4o5/aZpJpk1cfjw4ftKkVJ6TxZXrlw5li9fnijo9/b2pk+fPkyePJkhQ4ZQp04d1qxZw9GjR5k4cWKKU298fHyoVKmSYzrOiIgILl68yKBBg1LzdADw9/enSpUq7N+/n06dOt13Pb/++iuXL19mz549/PTTT1SqVImuXbsC8VN49uvXj7Fjx9K/f3+Cg4M5dOgQ27ZtY/jw4U717N69mxEjRlC9enV+/PFHQkND+c9//uO0T3q+PiIimd1Dvq4sfKMgFVbfYMRP0fc+4B4+fcpCt0oK9iX7mzZtGtOmTQPi041btmyJm5ubY3tcXBwXLlxgzpw5Ka5bQX8Wl3AD7sMPP4zNZnPa1qFDB7y9vZk/fz6//PILJUuWZMqUKU7z9KfE+PHjeffdd5k0aZLjpuC00rBhQw4dOkTTpk3vu45Fixbh5uaGv78/vXr14j//+Y9jBh/A8Yv06aefMmXKFPz8/Bg5ciStW7d2qmfw4MGsWLGCjRs34ufnx7vvvkudOnUStZeer4+ISFYw/AlPXN0MXl1x/4H/fx81FPDLA8vso/oJgoKCyJs3L6Zp0r17d3r27ElAQIBju4eHBzVr1qRMmTIprtsw03vOJJG7WLt2LeHh4fzvf/+jdOnSvPPOOxndJREReUCvrbjBxF9sYLEAJrhZ42fbcbXEL/8WYxhO86nXKwI/d9T4pDy4qY+uS7J80LbH07knyWexWNi9ezc1aqTOHei6dJZM5ffff+edd97By8uLV155JaO7IyIiqWBCC086VE158P7js3qAlqSOrJjT36VLl0QzCD4IjfSLiIhImjNNk+BPo9h0wp6skf75Txl0qaSgX1LHlHrrkywf/EvjdO5JxtF3ZiIiIpLmDMNgbVcPKky/wZF7POrE1xM6V1QygqSezD6qfyc///wz27Ztc5odMC4ujq1bt7J+fdIXMneioF9ERETShYvVYHcfT/ymRBFpu/N+S1tb7/tBkSJJyYpB/7Rp0xgyZAiFChXi4sWLNGjQgJMnT3Ly5MlEk44khy6jRUREJN3k9jDY2/tOz/6FmoWgftGsF6CJpLb333+fDz/8kEOHDmG1Wvnoo484ePAgtWvXTjRVe3Io6BcREZF0VbaAhfWdkg5BlrVRHr+kvqx4I+/FixepUqUKuXPnpnr16uzYsQMPDw+GDh3KggULUlyfgn4RERFJdw1KWBiRbzkuxDnKNrQ3KOKTuQMxkfTyyCOPsHDhQmJiYmjYsCFr1qwBwNPTk+vXr6e4PuX0i4iISIYIcA1hRt7PCGrbjbK+Llgy+cirZF2mJet9tt566y1at25NrVq16NChA7Vq1eLUqVMcPHiQRo0apbg+jfSLiIhIhjEMKJUXBfwit3nyyScdAX61atVYvHgx+fLl45lnnuGTTz5JcX0a6RcRERGRbC2z5+/fScmSJR0/P/PMMzzzzDP3XZeCfhERERGRTOjq1assW7aMI0eO0L9/f7Zu3UqJEiWoVatWiutSeo+IiIiIZGtZcfaevXv3UqZMGV566SXeeecdLl68yKZNm2jQoAE//vhjiutT0C8iIiIikskMGDCARo0acfHiRUzTBOCDDz6gX79+jBw5MsX1KegXERERkWwtK470//bbbwwaNIh8+fI5lbdt25ZDhw6luD4F/SIiIiKSrWXFoN/Pz4+9e/cmKt++fTtFihRJcX26kVdEREREJJMZPHgwgwYN4vjx4xiGwapVq1i4cCEzZ85k0qRJKa5PQb+IiIiIZGuZfVQ/KX369MHLy4uxY8dimiavv/46xYsX58MPP6Rbt24prk9Bv4iIiIhIJtSlSxe6dOlCeHg4pmmSK1eu+65LOf0iIiIikq1lhZz+cePGcf78+SS3+fj4PFDADwr6RUREREQy3NixYzl79myi8j179hAdHf3A9SvoFxERkXRhvr8Ks1B3qPIKXA133rhuP7g8C0ZbGPdVhvRPsi/TSHrJTBLm4r9drVq1+PPPPx+4fgX9IiIikubsY5bCoIUYF0PhwClcivXCsNnjN16PhCZjIGF99Fcw8n8Z1FORzOVOFwMppaBfRERE0lTs13swxy5zKjNibLSYtAMAa4t3Eh/01mL44df06J7kAFkhpz+tafYeERERSTNxF8KJfP4zfJLY5nf8Gi0mbsdyNDTpg5u/Bcc+hFJ+adlFkUzjyJEjuLgkDs//+uuvRGVVqlRJUd2GmVrfGYiIiIjc5qTv++S9chIfrmEhEoOYlFVgALZvIYeNykrqGvvUziTLR/9YO517cmcWiwUjic95QqiesM00TQzDwGazpah+jfSLiIhImjg8chfuV248WCUmMOhTeL9HqvRJciZ7Frho3LBhQ5rWr6BfREREUt2VS7EcnXmIiqlR2bSVMPI58M2dGrWJZEqNGjVK0/p1I6+IiIikKtM0GfPqidSttOXbqVuf5CgmRpJLTqKgX0RERFLVsvnniYlO5VsGt/8FJ5J+WqmI3JuC/nS0e/duAgMDWbp0qVP5mDFjePzxxzOmU8lgt9uZN28eLVq0oF69enTu3Jldu3ZldLceWGBgIMuXL0/WvsuXLycwMDCNeyQikvVdvhDN5mWX06bywNfSpl7J9jRlp4J+SYZZs2bx4Ycf8vDDD9O/f3/Cw8N5+eWXOXToUEZ3Ld1Ur16dcePGZXQ3REQyNbvdZOyQv9OugZBwmP1j2tUvko0p6Je7Cg0NZdGiRdSuXZvJkyfTsWNHZs6ciWEYfPzxxxndvXTj7+9P8+bNM7obIiKZlmmavDLqLLGxadxQn4/gp9/SuBHJbjTSr9l75B527NhBbGwszZs3d8wPW7hwYapVq8b27dux2WxYrdYM7qWIiKSV0Cg7HVfaOXIVyuWD58pZaOgVw6Dpl4mOsuMaZ6PwtUjCPdyJcHEjXR6j9dSbN3/2dItfAJ6oBv8bpDn9RZKgkf5MyDRNFixYQMuWLalXrx49evTg999/d2xv2bIlEydOpH///tSvX5+PPvqIL774gkaNGtGxY0cuX76ZS/n111/Ttm1b6tevz4svvsjWrVtT1Je///4bgBIlSjiV+/v7Ex0dzfnz53n++ecZO3YsAB9//DGBgYEcOHAAgCeffJIpU6YAOO5n+OGHH2jdujWPPfYYAwcO5OrVq051r127lhdeeIH69evz3HPPJcq7P3v2LIGBgezevZs///yTQYMG0bhxY8LDw532++yzz2jdujX169enXbt2fP/990me48qVK3nmmWfu2B+4c05/Ql8WL15M165defTRR2nXrl2az7UrIpJeanxm54cTcDQUVp6Arj/a+c/UEAJOX6PcpTBKXY3ktyK+eMfZM6aDN2Li035CwuHLrfDsxIzph2RqGulX0J8hIiMjCQ0NdSwxMc5PJ5wyZQoffPABgYGBvPzyy0RGRtK7d28OHjzo2Ofbb7/l4YcfplKlSnzyySd8//33vPTSS/z111+sWbMGiA/Ap0yZQqNGjRg6dCgPPfQQgwYNYvfu3cnua0IAnDu389zICeuhoaGUK1eOkydPAnD8+HHHf8PDw7ly5Qrly5d3HLdp0yYmT55M27Ztad++Pdu3b2fmzJmO7StXrmTEiBFUrlyZoUOHUqlSJcaOHZvkDbeHDx+mR48eREREEBwc7PTY6u+++45p06ZRs2ZNhg4dSuXKlXnzzTf59ddfnepYv34977//Pu3ateO5555j27ZtTv1JrilTpuDn58crr7xC7ty5GTZsWKa62TkkJITo6GjHenh4OGFhYY71mJgYrly54nTMuXPn7rp+/vx5bn2gt9pQG2oje7Zx8hqJ5ImOc1q/7OOeeKeMsv3PbP1+ZMc2JH0ovScDTJkyxTH6nSBPnjwAnDlzhq+++ooOHTowZMgQAFq1akXbtm2ZNm0ac+bMAaBu3bq8/PLLLFmyhF9//ZX//ve/VKhQgc8//5zr169z/fp15s2bR+fOnenYsSMADRs2pGPHjnz77bfJnokm4YLk1oD61vWYmBjKly/Pzz//DMR/M/Doo4/y999/c+rUKQCnoP/nn39m4cKFjrIzZ86wb98+IH6WoA8++IBmzZrRr18/AIKCgjh27BiLFy+mZcuWTn2YNWsWI0aMoEWLFon6vW/fPvLkycOoUaMAeOaZZ/Dx8SH2tmTTX375hc8++4yHH344UX9SIjAwkHfeecfRVosWLVi4cCG1atVKcV1pIX/+/E7rPj4+Tutubm4UKFDAqczPz++u64ULF1YbakNt5IA2yuSL46/bvgC95uH8N6Fw2AM+dTc1NaqYrd+P7NhGejBz1qB+khT0Z4AXX3yRevXqOdY/++wzx0w4O3bswG6388wzzzi2e3l58cQTT/DVV18RFRUF4AhSXV1dk1w/cOAA0dHRfPrpp3z66adO7SeMxieHu3v86E1cnPOoTsK6u7s75cuX59q1a4SEhHDy5Enat2/Phg0bOHXqFB4eHgQEBDiOCw4OdroIKFmypOMbjJMnT3L58mVWrVrFqlWrnNrz8vJK1Lf69esnGfADVKxYkRUrVjBjxgyCg4N5+OGHefXVVxPt9/jjjzteO4BSpUrd16xETz75pONnDw8P6taty7Zt21Jcj4hIZrOnk4VuP5ocDjGp6Atty1qo71WAl6eZhEXacbPZqHTuKrhkUEiRyxNyeYBpQqvaMPv/MqYfkqnZc1gqT1IU9GeAkiVLUqdOHcf6Dz/84Pg5NDQUAF9fX6djChYsiM1m4/r16wCJbp69fST+2rX472NHjBiBv7+/0zYPD49k9zVv3rxO9d1ef758+ciVKxeGYfDLL7+QK1cuKleuzLx58zh58iQPP/wwFsvNLLIKFSo41WPc8kuYUGfv3r2pUqXKHfdLcOuF0e3atGlDaGgoK1asYP78+Xh4ePDkk0/y6quv4unpmaz+pMTtIyF58uRJdI+BiEhW5O1m4etWt5e6s3hSUaeS6e/9w7rDtnTrF1cWQP5c6deeSBanoD+TSQiyL1++7PgZ4NKlS1it1kS59XeSkC5UpEgRpwuMM2fOOOXi3Uvp0qUBOHHihFMgfurUKTw9PSlUqBAWiwV/f382bdpEqVKlKFGiBBcvXuSvv/5yGtW/tV9363P+/Pmd+nzhwgUuXryI3W53uoBI+BYiKS4uLvTs2ZOePXty+fJlfvzxR6ZNm0aBAgXo27dvsvqTErfePA3xOZC5cumPkYjkHC8PK8qpMWcJT49HuGx6UwG/pEhOu2k3KbqRN5OpU6cOFovFaaaZyMhIVq9eTbVq1ZI9Sl+5cmXc3d1ZvXq1o8xutzN48GCmTp2a7P7Url0bNzc3p28jzp8/z759+6hbt64jCC9fvjybNm0iICAAFxcXihQpwpYtWxIF/XdTokQJfH19Wbt2rdMNPuPHj2fEiBFOAf+9DBo0yHFDrq+vL//5z3/w9/fnyJEjya4jJW59fW7cuMGOHTuoXLlymrQlIpJZTRzth7tHGgdX8wZAw4pp24ZINqSR/kzG39+f559/ni+++ILw8HDKlSvH999/T1hYGAMHDkx2Pblz56Zz587MnTuXqKgoAgMD2b59OydOnEhR0J9Qz8cff8zw4cMJDAzkq6++wmKx0KNHD8d+5cqVY82aNZQqVQqIz40/efJkioJ+i8VCv379GDt2LP379yc4OJhDhw6xbds2hg8fnux6EvqzcOFC7HY7xYoV448//uD06dN3TQl6EL///jvDhg2jRo0arFq1ioiICLp06ZImbYmIZFaGYTBmcknG9zycNg0UygNdg9OmbsnWNNKvoD9TGjx4MAUKFOCbb77hxx9/pEKFCsyePTtR/vm99O7dmzx58vDVV1+xefNmSpQowcSJE2nQoEGK6/Hw8GDx4sVs3ryZMmXKMH36dKeAPuHnhJt2AwICcHNzc1wEJFfLli1xc3Pj008/dUyDOXLkSFq3bp2iel566SUsFgs//PADFy9eJG/evHTv3p1OnTqlqJ7kevXVV1m2bBnTpk2jSJEiTJw4kWrVqqVJWyIimVk+X1eatH+Ipd+Hpn7luzUHv8j9MkxNlCpy386ePUurVq2YPXt2sqdBFRHJCQb1OMLj322j4tV/yM9FfLiGhUgMYu59cFIaVoBN41O3k5JjvNrmQJLlk77LOam4yukXERGRVDdmUkDqVvh9ytI8RcSZ0ntEHkCRIkVS9IRjEZGcIk8+V8oNrQyv//PglQ1rA3l97r2fyB3o4Vwa6RcREZE0UnZEdSyFHjBYd7XCO/9JnQ6J5GAK+kVERCTN+P/R467bT1YscPcKjs8GzbwiD8jESHLJSRT0i4iISJqxFvDCa1nSgf/p8vn56eVa2BvdYXa69WPB/x4XBSKSLAr6RUREJE25tqyEMeE5pzLTy40fXo6f9cy2dFjig95+EYJzzswqkrbshpHkkpMo6BcREZE0ZxnaDD7pjVm8INQuS9yZuWD9Nwzx9oCtb4G7C1gMmNwFRrTL2A5LtmIaRpJLTqLZe0RERCRdGN2Dofu/T9SNjXXeWP8RiPo6/TslkkMo6BcRERGRbC2njeonRek9IiIiIiLZnEb6RURERCRbs2ugXyP9IiIiIiLZnUb6RURERCRbU06/RvpFRERERLI9jfSLiIiISLZmRyP9GukXEREREcnmNNIvIiIiItmacvoV9IuIiIhINqcpO5XeIyIiIiKS7SnoFxERkQxht8OxqAKcD7NndFckm7MbRpJLTqL0HhEREUl3f1620+9sR+wWKxOm26lROIrN3d3wdtN4pEha0G+WiIiIpKuIGJMqs+zYsTrK9lyE/2/vzuOiqt4Hjn9m2DdBXFEUzS0XXBLFJBXUMkUUdzH9uu9biqZ+1UR/VhqJgSkumTtmWV/XMrXUqFwrrTRz30LcUfZt7u8PYnJkm4FhcXjer9e89N577j3PPXOBZ84990z5JakkpkqvvzA+RaXK9lWaSNIvhBBCiCLVe1syyrMrVZCUDu6rU4sjJCFMniT9QgghhCgyf9xJZ9+lLCm/1uVHEHo8rQgjEqWBRpX9qzSRpF8IIYQQRcYzPCnPMm8eSCc+RYb5CGFMkvQLIYQQokh8fDKNBD1H7/TeLr39wngUVNm+ShNJ+oUQQghR6J4kaRi5M0Xv8vuuKPx2R3r7hTAWSfqFEEIIUeiahMQZvE/nrakoSs7j/4XQl8zTL0m/EEIIIQpZj00JXHtoeK99VBxMPZBeCBGJ0kaS/kJK+q9cucK4cePw8vLC19eXTZs2FUY1z63ibJ+goCBGjRqVZf3u3bvx8PAotHpPnTqFh4eH9uXp6UmvXr346quvCnzMqKgoI0YqhBDCWBRFoc+WBHb8mf/E/cMT6az6WRJ/IQrK6N/IGx0dzciRI7Gzs2PixIncvHmT0NBQAAYNGmTs6opUbGwsERER+Pn5UaVKlXwdo6S2T7NmzViwYEGO241x7gADBw6kbt26pKam8t133/H2229TsWLFQv3AIYQQouhdiE6j88YkrjxSKOjzkmO+TgMURjc3etoiSonSNj1ndoz+0xMeHk5cXBzr16+nWrVqQEbCuG7dOvr374+FhYWxqywysbGxrFmzhubNm+c78S2p7ePq6oqrq2uO241x7gDNmzenTZs2APj6+tKrVy8iIiIk6RdCCBORkpxO4PYEtpxM4ZGtldGOO+brdM7f17C0k6XRjilEaWLUpD81NZVDhw7h6empTWgBWrduzVdffcXly5d58cUXjVnlc0XaR5e5uTk1atTg5s2bxR2KEEKYvvR0mLkZZftJSAY6NISFvVFN+QRl/2mITwbUKOY2qABFk4pKk0YK9qRij5o01KRiQTwJlCUZByxIxoG/UZExXj9FbU7fNxZxqLxToYwf/vCkwocnk8BcDekKpKSDuYpWlVUcHmqFlfm/3bnJaQpTD2s4Fa3QtZaauS/LY4ylmaaUTc+ZHaP+BFy5coWEhIQsiWutWrV49dVXMTMzA8DDw4Pdu3frlFm1ahV+fn7a5aioKDw8PDh16hR//fUXU6ZMoX379sTFxRlUBuDgwYP0798fLy8v+vTpk6VuDw8PduzYwddff42/vz9t2rRh8uTJPHr0SBubh4cH3bp1A2DMmDHasemGjCfXt32MdV6pqaksWbKEDh064OPjw7Jly3KcBSGnMf3GOvec3L59GycnJ+2yoihs2LCB7t274+XlRd++fTl48KDBx9XnOHm975m+/PJLevbsiZeXFwEBARw4cCBLfXm9F0IIUexW7EP5YDdcewy3H8Pmn6Dju/C/46jik/9JiaxQpQFpoNIopGNNMs5osCINOzRYkIIN8VQkDRvSsET9TzqlApIsrUn9529Z4VGBmQqszDKS/xSFY9Hw32915/VfdEJhxWmFE9Hw9o8aPjsv03+K0s2oSf/t27cBqFChgs76OnXq8N5771GnTh2Dj3n+/HmGDx9OfHw8Pj4+mJtnvTmRW5m9e/cya9Ys3N3dmT59Oo0aNWL+/PlZkrIjR46wZMkSevbsSd++fTl27BgrVqwAoH379ixYsICpU6cCMHToUBYsWMCCBQsoW7as3udiaPsU9LwWLVrE1q1b6dChA6NGjeLbb7/l0KFDesdrzHPPFB8fT0xMDNHR0axcuZIrV67QvXt37fbNmzezbNkyWrduzfTp06lVqxazZ8/m6tWrBtWj73Fye98BNmzYwLvvvkvt2rWZOnUqVapUYdasWRw5ckRbRt9rrDg9fPiQ5ORk7XJcXByxsbHa5ZSUFB48eKCzT+b1mtNydHS0zodIqUPqkDpKdh3pV6J5dnC95t4T7f8zjvT0dgUFtc46DeZo+Hd4jRn6z7tfKNQq0CigUnHhwb9J/e3bt7n+RLeT6+rjkvV+SB1FOxWrolJl+ypNjDq8JzExEQBLS+ONtwsPD2fWrFl07drV4DIajYZly5bRuXNnxo8fD4C3tzeXL19m+/btOncWfvzxRzZu3Kjthb916xZnzpwBMpLyOnXqEBUVRUhICJ6envkag25o+xTkvB48eMCePXvw9/fnv//9LwBt2rShV69eBsVsrHPPNGfOHJ3lPn366Jzfw4cPGTRoEJMnTwbAz8+P9u3bc+LECWrWrKl3PfoeJ7f3PfM5ho4dO7Jo0SIAevToQffu3dmxYwft2rUz6BorTs7OzjrL9vb2OsuWlpaUK1dOZ52Li0uuy5UrV5Y6pA6p4zmqw2xwe5Q130K8BlCDmRr1f16Bj/aAkvHdpAppQOazZSrMSEJNyj+JvoI5iZgTRxzlUTAnGVsUVKhQKPLZ9JV/hvdYqSFdw2TPf/+2uri4MCRNYev5dJLSoLwN9Kn3bz9nSXg/pA5R1Iya9Kv++cSk0ejeQktISODmzZu4urpiZ2dn0DG9vLxyTfhzK3P9+nXu37/PV199lWVqSFtbW51lHx8fnWE3NWvW5Ny5cwbFmhdD26cg53Xu3DnS09Np3769dpurqytNmjQx2vnkx9ixY2nUqBEJCQkcOnSIzz//nHLlyjFixAgAJk+ejKIoXLx4kbNnzxIZGam9O2AIfY+T2/v++++/k5SUpPMeqNVqnR58Q64xIYQoVk1rojr7IUrkn5CkgVa1UTWqBiN84JvTpB+9COaWqGtVhLhEFAcr0s9EY/HbLZQ0BbOWVeFxeTRHL+KQco0U8zJYKukkp9thRhJpqElWrIvkVMqkp/EkVcHCAl6qCGu7W9Gwku7ghbbVVPw+2Iw/7it4uqhwsS9dvbpCl8zeY+SkP3Ns9uPHj3XWnzlzhokTJxIeHk6LFi2y3TchISHb9U8P/chJTmUy4xg9ejSNGzfW2aZ65pZOgwYNct1uDIa2T0HOK/PW27Of0MuXL8/9+/fzfxIFVLduXTw9PYGMhPvx48esXr0af39/ypcvz7Fjx1i4cCHR0dG4uLjQrFkzypQpY3A9+h4nt/c9s52f7cF4miHXmBBCFDu3iqjcKuqua1wDGtfg2ZH4KnIeA2wJPNutYQHYAMN2xxB5qPDGzx8bao5nVf2eG6hdVkXtsvK7WAgwctJfq1YtAC5duqSz/s6dO0BGwpmTnMZsW1nlPd1XTmUcHR2BjMQ3M9HMjOfu3btoNBrUarVO2cJkaPsU5Lwye5mf7dl+9iHV4vbCCy/w448/EhUVhbW1NTNmzKBp06asW7dO++yDoUNk4uLi9D5Obu975rZnxyru2rWLX3/9lXnz5hl0jQkhRGnQ28+Jtu00DNsQy97beZfXl5UZXB5vQdUy8jtVGK60fftudoz6k1OhQgXc3d2JjIzUSZSOHDmCs7Mz1atXB8Da2lpn+9WrVzl27JgxQwHAzc2N8uXLc/DgQZ0HRhYuXMisWbMMTsYye4pzuiuRF33bJy/6nFf9+vVRqVQ6D5xGR0dz+vTpfMVe0HPPye+//w5AxYoVuXHjBvHx8fj6+moT9VOnTmk/FOnLWMdxd3fHysqKvXv36qz/4osvOHv2LGD8a0wIIUxBxTJq9kx0JKKvcebpr2ALDwIl4Rf5p0GV7as0MfqXc02dOpXRo0czduxY+vbtyy+//EJkZCRTpkzRTknZuHFjvvzyS1q3bk1qaipBQUHUqFFD+6CrsajVasaPH8/8+fOZMGECPj4+/Pnnnxw9epSZM2cafDx7e3saNWrE6tWrefjwIfHx8dy9e5cpU6bofQx92scY51WpUiU6derE9u3bgYzk9LPPPst3EmqMcwf4+eefiY2NJTY2lh9//JHTp0/TsmVLKleujI2NDVZWVmzYsIH4+HguXbrEjh07UKlUOjMH5KVq1apGOY6DgwMjRoxg+fLlKIqCh4cHx48f5+zZs9pvLzb2NSaEEKYkoKkFHlVV1F2a/7/v1mZwdYIldpalK0ETwtiMnvS7u7sTHh5OWFgYISEhODs7ExgYSEBAgLbMzJkzmT9/PkOHDqVixYoMGzaMqKgo9uzZY+xw8PPzw9LSkk8++YSQkBBcXFyYM2cO/v7++TrewoULWbRoER988AFmZmba+ev1pU/76EOf85ozZw4ODg7s27cPjUZDly5diIuLM7jHO1NBzx0yptKEjKFLlStXZsSIEQwcOBDIGE6zePFiwsLCCA4OxtXVlXnz5vHpp59y8uRJvesw1nEgY4pSBwcHNm/eTGRkJDVr1iQ4OBgfHx9tGWNfY0IIYUrqVDDnzERbmiyJzbtwNs6OkYRfFFy6XEKolKKeKFUIIYQQpc7KoymM3ZuWMdWmuRrtHJ+ZN6DNVPDMuOtpnmqCX7VAiILqNvxmtut3ra1WxJEUHxkcJ4QQQohCN+ZlS14wcCadRR0K+9t9RWmhUamyfZUmkvQLIYQQokicGKP/g70RPcwwk8kQhDAa+WkSQgghRJEoZ6dmbMu8HyesYg8BDY3+2KEoxTSq7F+liST9QgghhCgyoV0t8yxzariM4xfC2CTpF0IIIUSRsTBTsXtAzon/qi5muDhIeiKMS+bpl6RfCCGEEEWsaz0zOtd+ZqUG5r6iZtRLMqxHiMIgSb8QQgghityO/ma8Zv8Hjqo4XqoM3/3HggXeMqxHFI50lSrbV2kiH6eFEEIIUeRUKhW9nH6ll9OvDB06FAsLmZ5TFJ7S9tBudqSnXwghhBBCCBMnPf1CCCGEEMKkpZeyh3azIz39QgghhBBCmDjp6RdCCCGEECYtXTr6padfCCGEEEIIUyc9/UIIIYQQwqRpStn0nNmRnn4hhBBCCCFMnPT0CyGEEEIIk1bavogrO9LTL4QQQgghhImTnn4hhBBCCGHS0oo7gBJAevqFEEIIIYQwcdLTL4QQQohipdFouPTlNVQqFbV6uBV3OMIEyZh+SfqFEEIIUZwU2Nv5ELFX4kgzU3N28xW6feFT3FEJE5MmOb8M7xFCCCFE8VEfsSb2ahwAilrF3d9i+DX8r2KOSgjTI0m/EEIIIYpHGlgctf13WVEA+DnkHJp0TTEFJUxRGqpsX6WJJP1CCCGEKBYWv1jkuO23NReLMBIhTJ8k/UIIIYQockq6gvUemxy3//6xJP3CeFJV2b9KE0n6hRBCCFHkLq+6QG6jK5Ifp/L4elzRBSSEiZOkXwghhBBFSpOSztmFv+dZ7uQHZ4sgGlEapKpU2b5KE0n6hRBCCFGk9o87qVe5a/uiSEtKL+RohCgd9E76t2zZQosWLbh27ZrO+q+++goPDw9OnTpl7NhKpJiYGGbNmoWPjw9eXl4MGzbM4GNcuXKFcePG4eXlha+vL5s2bSqESLMXFBTEqFGjsqzfvXs3Hh4ehVbvqVOn8PDwYMeOHVni6dChQ5byq1atws/Pr9DiEUIIUTx+33aNG0fv613+l4/+LMRoRGmRmsOrNNE76e/RowcODg5s3bpVZ/2nn35Kw4YNCzVhLElCQkI4ffo048aNIzAwEDc3w745MDo6mpEjR3Lr1i0mTpyIt7c3oaGhRZr4Z6dZs2YsWLAgx+2xsbGsWrWKqKioIomnffv2BAYGFugYUVFRrFq1itjYWCNFJYQQIr806QoHgv/ih//Le1jP035bdRFNulJIUQlReuj9jby2trb06tWLrVu3Mn78eMqUKcPp06c5d+4c77//fmHGWKL88ccfdO3alT59+gDQs2dPg/YPDw8nLi6O9evXU61aNSAjoV63bh39+/fHwiLn6csKk6urK66urjluj42NZc2aNTRv3pwqVaoUejx16tShTp06BTpGVFQUa9aswc/PDwcHByNFJoQQwlCXjj1ky/yL2MQlkZ/fxj/M/oW2i5obPS5ReiSUsvH72TFoTH///v1RFIUvv/wSgIiICKpXr463t3dhxFYipaamYm6u92elLPseOnQIT09PbcIP0Lp1a548ecLly5eNFaYQQohSTlEUNP982ZWiKCiKAhrdL7zSPLMuLiFZuy4lNY3klFTSk5NRNBoSU9NISkkjPimVJwnJPH6UQEJyCrGxiSQkJJKclMSDuGQe3n3E7b+f8Oj2Q37YcZOwfieImPUnqqS0XGfryc2FL25w+9d7JMenoGgyzkWTrkHRyB0AoZ9EVfav0sSgpL9cuXJ06dKFzz//nFu3bnHkyBEGDRqEWq17mIMHD9K/f3+8vLzo06cPu3fv1tmuKAobNmyge/fueHl50bdvXw4ePKhTJioqSvuswF9//cWUKVNo3749cXG603dt2rQJf39/vLy86NWrFzt37jTklLR27dpFr169aN26NQMGDOCHH37Qbsscj+7h4cHt27dZs2aNdvnZc8vNlStXSEhI4MUXX9RZX6tWLV599VXMzMwMOve82jk1NZUlS5bQoUMHfHx8WLZsWcYv/WzkNKZ/1apVeHh40K1bNwDGjBmjPffCHOqT25j+1NRUli1bRteuXfHy8mLAgAEcOXJEuz0oKAgPDw/GjBkDQLdu3bQxPy3zOvTz86N169YMHz6cP/74Q6dM5nsfFRXFqVOnGD16NL6+vtrtn3/+ebZtMWnSJAICAgrUBkIIkV9hv6RjHpKO2ZJ0Kq1Iw2FpKg7vxbPFcxks/ByAuT+kY/VBKlWCHnCo/jwqznuAw3I1Vu8now5OpcVbV7ldaTzXqkym6rz72H6oUGFxIvvc15Nk/3/8WXcl7SZfJapGIDZ2b2Bu+wZLeuykxZIkqkTY0Pm9ZCKXXuPJ/TSjnNNnbxzD6b9PGOBzgk/LbuMbq818Y7WRy6OP5L2zEEL/4T2ZBg0axM6dOwkMDMTJyUknAQLYu3cvQUFB+Pv7079/f86cOcP8+fMBtEnc5s2bWbZsGX369KFevXocP36c2bNnU6tWLWrWrKlzvPPnz7Ny5UoaNGiAj4+PTi/7//73P0JDQ+nevTvu7u6cPn2a//u//8PV1ZXmzfW/Dbh161aWLFlCu3bt6NevHwcOHGDq1KkEBwfTrl07atasqR3vHhISQrNmzfDx8QGgcePGetdz+/ZtACpUqKCzvk6dOrz33ntZyud27vq086JFi9i5cyc9e/akZs2abNu2jYcPH2b50JGb9u3bU61aNWJiYggJCWHo0KHa96hs2bJ6HydTQkICMTEx2uWUlBSDj7F69Wo2btzIwIEDcXNz48iRI8ycOZNt27ZRvXp1evbsScuWLbl69Srr1q1j6tSpODk5ZTlOSEgIW7duxc/Pj3r16rFz505Gjx7NmjVraNCggU7ZyMhIli5dSsuWLXXubL366qssWbKE/fv3M2TIEACePHnCiRMnGD9+vMHnJoQQBfUgUeHN7xQyu3juJgCowdKa4T1H0nfOYP7s1JaFx8qBSs3tMmX5yKMj9xwcAUgzM8ciLZWluzdSI+Y+bwRM5LajMwBxNjY8tLNDrSjUvv+Adds/od7DaADMFIXrFSpw5Z+/cTZpGlQ5dDTlh11qGkkW5nz+Uh16n7yccdNAUXH148tUmdgIm0bljFaXMD0p+b3NZEIMnrIzczjP5cuXCQgIwNLSUrtNo9GwbNkyOnfuzPjx4/H29mby5Mk0aNCA7du3a8s9fPiQQYMGMWPGDPz9/Vm4cCHW1tacOHEiS33h4eHMnDmT1atXM3fuXKytrbXbzpw5g6OjI3PnzsXf35958+bRv39/UlP1fx47Pj6e8PBwvL29WbJkCX379mXlypXUrl2bkJAQ4N87HF26dMHGxobatWtrl3MbB/+sxMREAJ02y01O565POz948IA9e/bg7+/Pf//7XwICAvjoo49ITk7WO17I+EDSpUsXbaLr6emp0xaGCgkJoWPHjtrX/v37DT7GmTNnqFevHpMnT8bf35/58+fj7+9PfHw8kPFBrEuXLnh6egLg7e2tjTnTrVu32LZtGwEBAdrrZu3atTg4OBAaGpqlzhUrVhAWFkZYWBjTp0/XrndycuLll1/WOY/Dhw+j0Wh4/fXXDT63wvLw4UOd9z4uLk7nAeeUlBQePHigs0/mh9SclqOjo3XuHEkdUofUUTLqSNdATql2mtqMdLWa1FTdYT6pZln7AC006dluS/3nrjSAuSb9mW35G/5qCI1ahUZnfLaKe3/f0SlTkt4PqSPvOkTRyNdP5yuvvMJ3333HK6+8orP++vXr3L9/n6+++oqvvvpKZ5utra32/5MnT0ZRFC5evMjZs2eJjIwkPj5epwc4k5eXF127ds02joYNG7Jnzx4++ugjfHx8qFu3LtOmTTPoXH777TcSEhK0w1cAzMzM6NatGx988AE3btygevXqBh0zJ6p/fklpnhlTmZCQwM2bN3F1dcXOzk67Pqdz16edz507R3p6Ou3bt9duc3V1pUmTJkY5l/x64403aN26tXZ506ZN/PmnYdOxNWzYkIiICDZu3MjLL7/MCy+8wIwZMww6xvHjx9FoNHTv3l27ztbWltdee41t27aRlJSk8wGzR48etGzZMttjdenShVmzZnHt2jVq1KjBwYMHadGiRZY7OsXJ2dlZZ9ne3l5n2dLSknLldHvJXFxccl2uXLmy1CF1SB0lsI6KVjDLU8V7xzOSKjsLSExVQKOwZM9GrMd0pHlrF0bEpvPx7wp2yUmMOPEt39VxJ97KGrVGQ6qZObM6D2D3usW8fWA7B+u488jWHuvkZOreyUiw79rb8aZfbzZ9EUql+CcAeFy/zKEXGnG/kCZPUCkKPX+5RLq5CpIBFFx9K1O9k+7d2ZL0fkgdeddRJKSjP39JvyqHJ6AfP34MwOjRo7MMe3l6n2PHjrFw4UKio6NxcXGhWbNmlClTJttjPp2UPatHjx7ExMSwZ88e1q9fj7W1NZ06dWLatGl690JnftAoX768zvrM5YcPHxot6c8cYpLZTpnOnDnDxIkTCQ8Pp0WLFtr1OZ27Pu2c+Sn82R/W8uXLc/++/vMjG1vNmjW1PfAAX3/9tcHHGDVqFGlpaXz66aeEhYXh4OCAv78/EyZM0D4XkZec3vcKFSqQnp7OkydPdJL+3K7Dtm3bYmdnxzfffENAQAAnTpxg7ty5Bp+XEEIYy7ttzAj00BCTDG5lVMSnAgkpOA7rB+Uz/t6u6WTGe20U7GIVbN6cxr24ZNb+dI9WLctTO/UJP92tytHO71I/5SE/vAiHn6ThkJ7ON9X68vWNB6jS02njbMHahoFUsVNIUan4RXFm1Mnj3FXb4JRohWLEREtlpuK7evdxH1MXG7uGJF6Pw76aLVau9nnvLITIX9KfE0fHjPGAzs7OOondnTt3uHv3LhqNhoSEBGbMmEHTpk1Zt26dtjc0p4c2rayscqzP3NyckSNHMnLkSO7fv8++ffsIDQ2lXLlyjBs3Tq+YMxPxZxPhzOX8jFvPSa1atQC4dOmSzvo7//SaPJuA5nTu+rRzZo//s3dPHj16lP8TKCFsbGwIDAwkMDCQqKgovvjiCzZs2ICbmxv+/v56HePp9/3p8f737t3DzMwsy4fQ3K5DKysr2rdvz/79+6lSpQrm5ubaZz6EEKK4lLNRU+6f/i9HK8DKCtD9XVbeVgW2Gb3yNnbWTOjhmLk3XWoAlAUyZpvL6Eu3Bq8yQPY9tRlf/VgVgNQUDce+uM2JrbeIjy34w7xdNr6CS8t//07aVrHNpbQQz5ApOw0f058bNzc3ypcvz8GDB3XGai1cuJBZs2ahVqu5ceMG8fHx+Pr6ahP+U6dOaRNfQ0yZMoUVK1YAGQnzwIEDcXV15eLFi3ofo3Hjxtja2rJr1y7tuvT0dHbt2kXVqlWN1ssPGb3I7u7uREZG6ox/O3LkCM7OznrXpU87169fH5VKpTOrTXR0NKdPn85X7JlJcEJCQr72N6Y33nhD++xClSpVGD9+PBYWFly4cEGnXGYyn13Mnp6eqNVqndmeEhIS2L9/P02bNtXp5deHr68v169fZ+3atfj4+OgMZxNCiNLIwlJNm4CqTN3Zktcn1CBNzzux2anevrJOwi+EMJxRe/rVajXjx49n/vz5TJgwAR8fH/7880+OHj3KzJkzAahatSpWVlZs2LCB+Ph4Ll26xI4dO1CpVAY/ZFqvXj02btyIRqOhWrVqnD17lps3b+Y6FONZdnZ2jB07liVLlhAYGIinpycHDhzg0qVLBAcH5ziUKb+mTp3K6NGjGTt2LH379uWXX34hMjKSKVOm6D00RZ92rlSpEp06ddImx25ubnz22WdZplfVl729PY0aNWL16tU8fPiQ+Ph47t69y5QpU/J1vIKoVasWK1as4NGjR1SsWJGjR4+Smpqa5XkFNzc3KleuTEhICJ06deLRo0doNBqGDRuGq6sr/fr1Y+vWrcTFxWln74mNjWXy5MkGx9S8eXMqVarErVu3DH6+QAghTJlKpaJlr6o0eb0Sexec487eJwYfo8Myz7wLCSFyZfTH7P38/LC0tOSTTz4hJCQEFxcX5syZox124ejoyOLFiwkLCyM4OBhXV1fmzZvHp59+ysmTJw2qa8SIEajVar7++mvu3r2Lk5MTw4YNY9CgQQYdJyAgADs7O9avX89PP/1EzZo1CQkJyfKgsjG4u7sTHh5OWFgYISEhODs7ExgYaPCc7nm1M8CcOXNwcHBg3759aDQaunTpQlxcXL7uqkDGnYRFixbxwQcfaB92Lg4zZszA0dGRXbt28eDBAypVqkRgYCCdOnXSKWdhYcEHH3zA+++/z+LFi7G2tmbo0KHa7VOnTqVcuXJ8/vnn7Nu3jwYNGminSDWUSqXCy8uLI0eO5PjArxBClGZWdub0XNyYn1ws+GON/l9G+WL/GphZGnVgghClkkqROZOEKJAdO3ag0WhYs2YNnTt3ZtKkScUdkhBClGj/6/U96d//Taq5ihTrf/ofFUg1V2cZe/2fX7tiaW9RDFEKU6IKjMl2vbLEqUjjKE7y0VmIAjp69CjBwcHUrl2bYcOGFXc4QghR4nXd+LJe5ap6VZCEXxiHKodXKVL436IhhIlbvHhxcYcghBDPFQs7C+pMqMe5lRdyLef5X/2/9V4IkTvp6RdCCCFEkXtxWsOcvzoYMLcxw7lu9t/hI4ThpKtfkn4hhBBCFDm1pZrkjkk5bm84uFYRRiOE6ZOkXwghhBDFIqVVSo7bmk14sQgjESZPOvol6RdCCCFEMbGEtGaJ/y7/M3NPg/+8gLlV/r/MSwiRlST9QgghhCg26a8lYumYMUOPSqNg72LDy3PkAV5hZNLTL7P3CCGEEKIYqcH/h06cX30JtYUa93EvolKVsmxMiCIgSb8QQgghipW5lRnNpjYq7jCESZMPkjK8RwghhBBCCBMnPf1CCCGEEMK0SUe/JP1CCCGEEMLUSdYvw3uEEEIIIYQwcdLTL4QQQgghTJt09EtPvxBCCCGEEKZOevqFEEIIIYRpk55+6ekXQgghhBDC1ElPvxBCCCGEMHHS1S89/UIIIYQQQpg46ekXQgghhBCmTTr6padfCCGEEMUjJV1NxC0PWi96wuj1scQmaYo7JCFMlvT0CyGEEKLIHbuQyqwLPVBrFMqma1j9KI0Nfz7h8cIyWFlIn6QwMpV09ctPlRBCCCGK1K/XUxkTHkeKKiMN0QCoVCQrKjquji/W2IQwVZL0CyGEEKLIpGsUuix9nOP2H65p2Hk2tQgjEqJ0kKRfCCGEEEUmeHscqXkM3fdfn0B6uozvF0akyuFVikjSL4QQQogiEZ+oYeuRxLwLKgoTd+pRTgihN0n6hRBCCFEk/vtJzsN6dKRrCP8+mbux6YUbkChFpKtfkn4hhBBCFLrYeA0/nk3RfwcVNH5fzw8JQog8SdIvhBBCiEI3bel9/Qv/M73inThY/oMM8xFGIB39+if9p06dwsPDgzlz5uisDwoKwsPDg6ioKKMG5uHhwe7du416zKKSnJzMO++8w6uvvkqrVq0YMGAAMTExBh3j8OHDDBgwgNatW9O9e3c+/fTTwgnWyK5du4aHhwfLly8v7lCEEEKUEOsiHnDhRlq+9p3wRSKPEmSYjxAFZXBP/7fffsvDhw8LIxaTsW7dOvbv38/gwYOZOXMmTZs2JS1N/192R48e5a233kJRFCZOnIirqysffPAB27ZtK8SojeP48eM6/5qKiIgITp06VdxhCCHEc2dPxB2+/uZJgY7htuAxyXlN+SNEbqSn3/CkPzU1lR07dhRCKKbj999/p02bNgwcOBB/f3/eeustypcvr/f+y5cvp0yZMqxatYqAgABCQ0OpW7cuq1evNujDQ3HITPbPnz/P48emMxZz69at/Pzzz8UdhhBCPDeiLzzhw74n+fp/BgzryUFsMlSb/4jYREn8hcgvc0N3sLKy4osvvmDw4MGYmZkVRkzPvdTUVMzNDW5aAO7fv8/58+fx8/OjTJkyAJibm9O+fXtWrlzJuXPnaNy4sTHDNZq0tDR+/vlnfH192bt3LydPnqRjx47FHZYQQgh9nb4KVhZoKjmTfvA8NxPT0VRwoHZ1G4hLIi06nrQTNzFzNCNx+x+Yp8WR/jgdTVwa6feTSVQrXHasyvnK9XhYrhypVhbgZJzQ4mOh2sxHWJlDeVU6VW1VVKlgTrkqllS0VdGqtgWt3My4cTOV8uXMKOuUv7/DwlSVsm79bBj8E/H666+zc+dOIiMj8fb2zrLdz8+Prl27Mnr0aO263bt3M3/+fE6dOkVQUBBRUVHUq1ePHTt20KxZMwYOHMiCBQtITU3l3XffpXnz5gA8fvyYwMBAjh07Rrly5Rg2bBj+/v469Z08eZIVK1Zw4cIFKlSoQI8ePRg0aBBq9b83MTw8PJg3bx4vvfQSy5cv58SJE6xYsYK6desadO6RkZGEh4dz9epVqlSpwtChQ+natSsAUVFRdOvWTVv2l19+Yc+ePQCMHDlSpz1yc+3aNQDc3Nx01lerVk27vXHjxvj5+dG+fXvu3r1LZGQkdnZ29O7dmxEjRqBS/Xth//XXX4SGhnLmzBmcnJx47bXXGDt2LJaWlgCMGjWKSpUqMWDAABYvXszFixdxc3Njzpw5NGjQwKD2+eOPP4iPj8fX15djx45x7NixLEn/r7/+SlhYGBcuXKB8+fL4+voybNgwnQ9J+pT57bffCA0N5c8//6RcuXL07duXgQMHas991KhRVKlShaCgIO0+p06dYsyYMezatYsqVarkee6Z5TOtWbOGNWvWADBv3jz8/Py023744QdWrVrF1atXcXBw4LXXXmPChAlYWFgY1IZCCFFsRoXDmgOkYckjyzooKVCGVMpylfu2VtgnaIgi4++CGg3pWKLGBmdukEwFbtlW4YGVPVeqViZNpUZRGTfJyvwLkJwGd1VmnEuxhNsqeGiGWWo6qkMJdE+IRRWfjpWliplvVqRRfWujxiCeY5LzGz68p02bNri4uPDZZ5/lu9IzZ84QFRVFly5d+Omnn5g9ezYBAQGo1Wq2bt2qLbd69WoSEhKYNGkS1apVY+HChezbt0+7/dSpU0yYMIFKlSoxffp02rRpw0cffaRNzJ52584dhgwZwo0bN2jXrp22F11fhw4dIjAwEHt7e6ZMmYKbmxtBQUHadihbtiwLFixgwYIF1KhRg2bNmmmX27dvr3c9jx49AsgSX+by0w8Ef/755/z9999MnDgRDw8PVq1axerVq7Xbr169ysiRIwEIDAzEz8+Pzz77jHfffVfn2Ldv32bixIk0adKE8ePHc+fOnSwPbOvj+PHjmJmZ0ahRIxo3bpxlXP/p06cZO3YsaWlpTJ48mXbt2vHxxx8TFhZmUJk//viDMWPGkJiYyKRJk2jevDmhoaE6ZfSV27nXrFlT+x46OTnh4+OjXW7WrJn2GFeuXGHatGnY2NgQGBiIv78/n332GevWrTM4HiGEKBZ3Y2DNAQAScUb5Z2ZNDRYk4kT5hDiSVHYomGNBMulYarc/oQqg4ppDBWrE3UNj5GQ/09MDe2onJf+zUoF0hXRLcyonp6KKz3jgNzlFYU8BnyMQwtQYnPSbmZnRq1cvTp48qe2VNpS9vT3vvvsuAwYMAOA///kPb7zxBi+99BJPnvz7Q1qhQgWWLVtGv379CA0NpUaNGqxfv167/aOPPqJp06bMnDkTb29vhg8fjre3N1988UWWOtetW0ffvn3ZvHkzc+fOpXLlynrHqygKISEh1KtXj/DwcPr27UtISAht2rRh+fLlxMfHY2NjQ5cuXejSpQvOzs5UrVpVu1ynTh2960pJyfhN++zwoMzlzO0AdnZ2rFy5kn79+vHOO+/wyiuvEBERQWpqKpDxoal8+fL83//9H+3bt6d///707NmTr7/+mvj4eO1xTp8+zfDhw5kyZQoDBgxg9OjR3Lhxw+AZh44fP07t2rWxtbWlSZMm3L59mxs3bmi3h4WFUb58edasWUPfvn2ZOnUqr7/+Ort27UJRFIPKODk5sXbtWvr3709QUBB9+/Zly5Yt3Lp1y6CYczv3cuXKad9DGxsbateurV12dXXVHuPs2bOkpaXx1ltv0aNHD0aPHs3kyZNxcnIyKJbC9PDhQ5KTk7XLcXFxxMbGapdTUlJ48OCBzj63b9/OdTk6Olr7nkgdUofU8ZzXYWsFNhmJvBrdZ8fUZCTSqn/qUp7pMs3cbqlJJ8WsaIbUJD91Nx8VqDQKqWrduBwc/i3z3L0fpawOUTTy9dPp7+/PmjVr2L59e74qrVGjBlZWVtqhD5nDbJ4dCvHaa69pk11zc3Patm3Lpk2bSEhIQKVScfbsWRRFyXbceExMjE7SVatWLUaMGJGveK9fv87t27d54403dJ5j8Pf3JzIykt9//51WrVrl69jPsrKyAsjywG7mcuZ2yLjrYmtrq11u164dP/zwA9evX6d27dr8/PPPPHz4kE6dOmWp58aNG9SvXx/I+HDVp08f7baaNWsCkJCQoHfiGhcXx9mzZ+nSpQsxMTHUqFEDyPggUL16dZKSkvjjjz944403sLb+93brggULtP/Xt8zp06cJCAjAxsZGu75Hjx589tlnnDx5Uichz4sxzr1+/fqo1WpWrFhB//79adCgAf3799c7hqLg7Oyss2xvb6+zbGlpSbly5XTWubi45Lr87AdnqUPqkDqe4zrsbWBbIEzbgK2FBWkOlUg5dRszTRyJNqncr+hG1ZhHJDyOIVljgzWPScUaSxJx5hpxVKfBoxtccKycMcd+Iedzf1uYY6XRoJiboVYUklLSiLOxoH4de+5fSaRqFQsG9imrLf/cvR+lrA5RNPKV9Ds5OdGpUyf27NmDp6dnnuWf7lUGsjwAnNMDwc/OeOPs7IyiKMTFxaEoCoqi0Lt3b3x8fLLs+3QyDNCtWzedse6GyOzxfjaeChUqAP8OyTGGzETz2ZlvMpfLlv33l9izP4iOjo5ARgKeuY+Pjw+9e/fOUs/TiXGdOnV07izkp51OnjxJeno6u3fv1vl+hWPHjtGnTx+ePHmCRqPJ8ovhaYaUyem9yG062YSEhCzrjHHutWvX5t1332XDhg1MmDAByHiOZNasWdpnMYQQosTzawF+LVABjs9syvyt7EL2rIHywAvA1oAfeXguxujhZf52tjCD6CXl8v03XZRScrnkL+kH6Nu3L7t27eKHH37Is2x+hwE9m0xnJr62traYmZmhUqmwt7fX+eDx6NEjbt26hUajO63X0z3khspMxO/f15127N69e4BuIl5QL7zwApAxHv9pmcNkMnvQs4snM+F1cHAAMj4EWFhY6LRPXFxclmNnflgoiOPHj6NSqViyZIm2rdeuXcupU6dIS0ujTJkyqNXqLLcAf//9dz777DNGjRpFhQoV9C6Tn/fi2fMG45w7QMeOHenYsSPx8fGcOHGCd955h6CgINauXWuU4wshxPOi78aXObXmIsd23uOJEWfYTAZ8XjBn+2gHSfiFyAeDx/RnevHFF2nSpInOOC8AGxsbnaQtJiaGr7/+Ol91HDhwgPT0jLGCGo2GyMhI3NzcsLe3x8bGhgYNGnDo0CHtGHaA8PBwvWfK0ZebmxsuLi7s3btXGw/Ajh07sLOzw93d3Wh1OTs707BhQ3788Uft8w1paWkcPHgQZ2dn7ZAcgO+//17bqw8Z3+JbpkwZ7cw/zZs35/jx4zrPSWzfvp2hQ4fqrDOG48ePU6dOHdq2bYunpyeenp60a9eO+Ph4zp49i7W1NY0aNeLgwYM618x3333Hvn37sLOz07tM06ZNOXDgAImJ/341+//+9z/UajUtW7YEsl6Hqamp2T7roS9HR8ds7xQAfPLJJ4wbNw7IeM7Cx8cHb29vLl68mO/6hBDieWVmocZzXD0m7fOizcCqqI00dntkWyv2TXbE3jrfqYsozVSq7F+lSIGeuOnXrx9nzpzRWefu7s6BAwfo3Lkzjo6OvPPOO1SqVIkrV64YfPybN29qZ3CJjIzk0qVLzJ07V7t9/PjxTJw4keHDh9O1a1eioqLYuXNnljHhBaVSqZg6dSpvvfUWY8eOpWPHjhw7dozIyEimT5+OnZ2d0eoCGDt2LJMmTWLcuHH07NmT77//nitXrjBz5kydoVBpaWmMHTuWrl27cvr0aY4dO8b48eO1w1VGjBhBZGQkQ4YMoXfv3sTGxrJp0yZeffVVqlatarR4o6KiuHnzJgMHDtRZn3mH4fjx4zRp0oQJEyYwbtw4Ro4cSdeuXbl16xafffYZ3bp10w5V0qfMpEmTGDVqFMOHD6dbt26cP3+ePXv2MGjQIO2wJXd3d9asWcPhw4epXbs2oaGhBbomPD092bFjBy4uLpibm3P8+HGCg4MBaNSoEeHh4cydO5fmzZtz//59vvnmG5o2bZrv+oQQ4nmnUqnwHlydeu2TmTwnqkDHGtnKko962eddUAiRowJ9XG7fvr12LHWmcePG4e7uzqRJk5g4cSJt27bNkgzqa+TIkSiKwtKlS7ly5QozZsyge/fu2u0tW7YkLCwMlUrFhx9+yKFDhxg7dizjx48vyGlly8fHh5CQEOLi4li6dCnXrl0jKCiIfv36Gb2uVq1aERwcTHp6OsHBwVy9epXp06dnGZvfp08fatWqxbJly/jll18YN24cQ4YM0W6vVasWa9asoVKlSixfvpydO3fSp08f5s2bZ9R4M6fmbNGihc76WrVq4ezszLFjxwC035OgVqsJDQ0lMjKSUaNGMWvWLO0++pTJTLKtra0JDQ3l5MmTTJo0iUmTJmnLvPHGG7z66qvMmzePoUOH4urqytSpU/N9jiNHjqR9+/asWbOGJUuWcPfuXe22li1bsnDhQq5du0ZISAhbt26lXbt2zJ8/P9/1CSGEqXCpZsU7QVXyvb+jNazqa9zONSFKI5UicyY9l7L7EjQhhBCipFq38wnLv0kkVaXibzM1lTQaLllaYJ2ejmO6wk0rCzD7Z+afdA38k56cnVGGBpXl23VFwajmJ2W7XplXer7ATQbGCSGEEKLQDfZz0L+wRgElY1iPJPzCKFQ5vEoR+Ul6Tj09LaYQQghR0qnVKib527NkZ7wehVVYqhVW9pFhPUIYi/T0CyGEEKJIDHrVNu9CAGZq/jfcHrW6lHXFikIkXf2S9AshhBCiSKhUKsLG5v39KK6O0KW+ZRFEJEoNyfkl6RdCCCFE0WnXyIoGlc1yLfPzZAPG/wsh9CJJvxBCCCGK1L5pjlia/9vN+nSH6+IuVlR0kPRECGOTnyohhBBCFClbSzXfv1OGhtZ3UAHpKrBI19D7RTPe8ik9UygKUZRk9h4hhBBCFDlrSzVjanxPTIoNdg160OFFa16sImmJKCSlbPx+duSnSwghhBDFxskykaFtrLCwkJREiMIkw3uEEEIIIYQwcZL0CyGEEEIIYeLkXpoQQgghhDBtKhnULz39QgghhBBCmDjp6RdCCCGEEKZNOvqlp18IIYQQQghTJ0m/EEIIIYQQJk6G9wghhBBCCNMmw3ukp18IIYQQQghTJz39QgghhBDCxElXv/T0CyGEEEIIYeKkp18IIYQQQpg26eiXnn4hhBBCCCFMnST9QgghhBBCmDhJ+oUQQgghhDBxMqZfCCGEEEKYNhnTLz39QgghhBBCmDpJ+oUQQgghhDBxMrxHCCGEEEKYNhneIz39QgghhBBCmDpJ+oUQQgghhDBxkvQLIYQQQgjxlMOHD6NSqYiJiSnuUIxGxvQLIYQQQgjTppJB/dLTL4QQQgghhImTpF8IIYQQQpg2VQ6vfPriiy9o1KgRjo6OdOrUiYsXLwIwfvx4Bg4cCEDLli3p2bMnAO3atWPRokUFOYMCk+E9Qpg4RVGIjY0t7jCEEEJHamoqiYmJADx58gQLC4tijkgUFwcHB1TP0fCbAwcOMGDAANauXUubNm1477338PHx4dy5c7Rs2ZKwsDA0Gg1qtZqoqCgA/vzzT+bNm1escasURVGKNQIhRKF68uQJjo6OxR2GEEIIka3Hjx9TpkyZ4g5Dx+HDh/Hx8eHRo0c4OTnpbPP19aVy5cqsXbsWyPgA6+rqysKFC3nllVdo0aIFv/76K3PnziUqKoqIiAjc3Nx49OhRsZ6n9PQLYeIcHBx4/PhxcYdRaOLi4vD19WXv3r3Y29sXdzjPHWm/gpH2Kxhpv4IxlfZzcHAo7hAMcu3aNdq0aaNdtrCwoEaNGly/fp0RI0Zgbm7O3r17qV+/Pvb29mzfvp0XX3yx2D/YSNIvhIlTqVTF/oumMKnVaszMzChTpsxz/UevuEj7FYy0X8FI+xWMtF/xqFmzJhcuXNAup6amcu3aNWrWrIlKpcLDw4OIiAimTZuGvb09ERERtGzZshgjziBJvxBCCCGEENmIiooiLi5Ou2xubs6bb76Jr68vHTp04JVXXuG9997DwsKCPn36ABkP8L733nvanv6TJ08ydOjQ4joFLUn6hRBCCCGEyEbDhg11lqtWrcqtW7eIiIhg3rx53Lhxg5dffpnvvvtOe1fd09MTMzMz6tatq70DIz39QghRQJaWlowcORJLS8viDuW5JO1XMNJ+BSPtVzDSfoXH29ub3Oa66dWrF7169cp2W/fu3UlLSwMyhgKVlDlzZPYeIYQQQgghTJx8OZcQQgghhBAmTpJ+IYQQQgghTJwk/UIIIYQQQpg4SfqFEEIIIYQwcZL0CyGeCz/++CN9+vShXbt2LFy4kOTkZIOPcfz4cdq2bUtUVFQhRFiyGaP9AD7++GNGjRpl5OhKvoK038mTJ+nfvz+enp506NCBzZs3F2KkJceDBw8IDAykbdu2DBo0iIsXL+q1X3p6Oh9++CEdOnSga9euHDhwoJAjLZny236PHz9mxowZtGnThtatWzNlyhRiYmIKN1jxXJCkXwhR4l26dIlp06bRqVMntmzZwuPHj1m+fLlBx4iLi2PBggWMGzeOKlWqFFKkJZMx2g/g/PnzfPzxx4UQYclWkPaLiopi2rRpdO/ena+//prAwEBCQ0M5depUIUddvBRFYfr06Tx69IiNGzfSr18/pk6dSkJCQp77hoeH89VXX/H+++/z7rvvsmTJEs6fP18EUZccBWm/t99+m6SkJDZv3syWLVu4ceMGS5cuLYKoRUknSb8QosT79NNPqVu3LiNGjMDV1ZW33nqLnTt3GtTbGhwcTKVKlejbt28hRloyGaP9UlJSePvtt3FzcyvESEumgrTfpUuXGDZsGAEBATg7O9OlSxeqVavG77//XgSRF58zZ87w22+/MWfOHGrUqEHXrl2pUaMGhw8fznW/1NRUtm3bxqhRo2jevDmNGzemf//+fP7550UTeAmR3/aLjY3F1taWxYsX4+bmRs2aNfH19TX5603oR5J+IUSJd/78eVq3bq1drlChAk5OTly+fFmv/Y8cOcLevXtp27YtX3/9NXfu3CmsUEukgrYfwPLlyylTpgwBAQGFEWKJVpD2a9u2LYMHD9Yux8XFcefOHWrUqFEYoZYY58+fp3LlyrzwwgvadY0bN84z+bx+/TqJiYm8/PLLBu1navLbfg4ODrz33ntYW1tr112+fNnkrzehH/lGXiFEiTBr1iyOHj2a7TZHR0dcXV111jk4OHD37l0aNGiQ63GTkpJ4//33qVSpEgkJCfz222988MEHzJ49m44dOxot/uJWWO0H8Msvv7Br1y62bNnCzz//bJR4S5rCbL+nrV27lsqVK9OmTZt8x/o8iIuLo1q1ajrrHBwc+Ouvv/Lcz8zMjKpVq2rXlSlThnv37hVKnCVVftvvWRcvXuTgwYOEh4cbMzzxnJKkXwhRIkyfPp2kpKRst40fPx4rKyudddbW1iQmJuZ53O+++447d+7w6aefUrt2bQCqV6/Oe++9h7e3N+bmpvFrsLDaLz4+nqCgIKZNm0aVKlVMNukvrPZ72okTJ9i6dSsrVqwwmesuJ+bm5lhaWuqss7a2znNMupmZGRYWFgbvZ2ry235PS0pKYvbs2fj5+fHSSy8ZO0TxHDLt3zpCiOeGs7Nzrtvu37+vsy4uLi5LcpCd6Ohoqlatqk34ARo1asTjx4+JiYmhfPny+Q+6BCms9luyZAkNGzbE19e3wDGWZIXVfpn+/vtvZs+ezYQJE0pFAubk5MSDBw901sXFxWVJZLPbLykpifj4eOzs7PTez9Tkt/0yKYrCvHnzsLa2Zvr06YURongOyZh+IUSJ17hxY86cOaNdTkhI4Nq1a1SuXDnPfV1cXEhKSkJRFO26qKgorKyscHR0LJR4S5qCtN+uXbv44Ycf8Pb2xtvbm0WLFnHmzBm8vb2Jjo4uzLBLjIK0H8CjR4948803adOmDQMHDiysMEsUd3d3rly5QmxsrHbduXPn8myzqlWrUq5cOU6fPq1dd/bsWb3b2lTkt/0yhYaG8scff7BkyZIsd6lE6SVJvxCixOvUqROHDx/ml19+AWDNmjWULVtWO546OTmZ+Pj4bPd95ZVX0Gg0fPjhh0RHR/Prr7+ycuVKOnfubFBP7fOsIO23a9cutm3bRkREBBEREYwZM4b69esTERFhMndJ8lKQ9ktOTmbixImULVuWKVOmkJCQQEJCAikpKUUWf3GoVasWNWrUYPny5Wg0Gs6fP8+hQ4do27YtGo2G2NhY0tPTs+ynVqt57bXXWLVqFfHx8cTExBAREUHbtm2L4SyKT37bD2Djxo188cUXLFq0CDs7O+01J4RKebr7SwghSqh169axcuVKnJycSEhIYPHixdoZVVatWsWRI0eIiIjIdt9Lly4RFhbGmTNnUKvVtGvXjpkzZ+rMcGHqCtJ+T9u9eze7d+9m9erVhR1yiZLf9jty5AiBgYFZ1nft2pWgoKDCDrtYnT9/nilTppCamkpsbCy+vr68/fbbREVF0a1bN7Zs2UK9evWy7BcXF8ekSZO4fPkyGo2GatWqsXr1auzt7YvhLIpPftuvffv2PHnyJMt6U/9uCJE3SfqFEM+Nv//+m4sXL9KwYUMqVKhQ3OE8d6T9Ckbaz3CJiYn8/PPPlC1bloYNG+q9n0aj4fTp06SkpODh4WHyDz7nJL/tJ0R2JOkXQgghhBDCxMmYfiGEEEIIIUycJP1CCCGEEEKYOEn6hRBCCCGEMHGS9AshhBBCCGHiJOkXQghR6DQaTXGHIESJJj8jorBJ0i+EEKJQ/f3333h4ePD48ePiDkWIEik4OJg5c+YUdxjCxEnSL4QQotCkpqbSq1cvWrdujaOjY3GHI0SJ1L17d1atWsXOnTuLOxRhwiTpF0KYhPXr19OwYUOsra2pX78+n3/+uXbb4cOHUalUfPzxxzr7DBkyhPLly2c51qxZs1CpVFy4cEFnfeZxMl/m5ubUq1evRHw77fr161GpVMUdRhYfffQRarWaDz/8MMu2oKAgatSoUeQxiYLz9vZmyJAh+dq3pF6rxalu3bps3ryZcePGkZCQUNzhCBMlSb8Q4rm3dOlShg0bho+PD0uXLsXJyYn+/ftz5syZfB3vwIEDOv8+a+jQoWzatInQ0FBq1arF6NGj2bJlS77jN1UxMTG88847LFu2LNtvVO3Zs2e2HwZKqmvXrhEUFERMTExxhyKMpCjf07zq6ty5My1atHiufibE80WSfiHEc+/999+nX79+fPTRR4wdO5b9+/fj4ODAsmXLDD7WgwcP+PXXX4Gck/6WLVsycOBAxo8fz1dffcVrr73G/PnzC3QOpmjnzp20atWK5s2bZ7u9cePG+Pv7F21QBXDt2jXmz58vSb8JKcr3VJ+65syZw7p16wo9FlE6SdIvhHiupaamEh0dTaVKlbTrHBwcCAoKyjHZzM23336LRqPhP//5D4cOHSItLS3PfXx8fLh06RKJiYkG12fKdu3aRa9evYo7DCGeGx4eHqSkpHD27NniDkWYIEn6hRDPNQsLCxo2bMimTZs4ceKEdv2bb77J2LFjDT7e/v37cXV1JSAggCdPnnD8+PE897G0tERRFJKSkvSq48svv0SlUnHp0iWd9b179+all17SLicnJzNjxgyqV6+Ovb09LVu25PDhwwadz7Vr11CpVFn2GzJkCN7e3jrrli9fTt26dbG1teWll15i7969BtX1rLNnz9KqVasct+c0pr9GjRpMmjSJTp06YWtry/z58wkNDcXR0ZGmTZsSHR2tfb5iy5YtNGrUCCsrK5o3b05kZKTOsfRpQ41Gw7vvvqst06pVK7799lvt9iFDhqBSqfDx8QGgZs2a2uc6DKUoCu+//z41atTA2tqaV155Recay3y/Dh48yNKlS3F1dcXR0ZGBAwcaNNZbnzbUJx6Ax48fM3jwYMqUKUPlypVzHH5i7OsnJ/q2YW7XvD7vqT7XmLHqelqrVq34448/8tM0QuRKkn4hxHNvxYoVpKWl0apVK3r16sVvv/2Wbbm4uDju37+vfSUnJ2cpc+DAAVq3bs3LL7+MSqXKcYjP086ePUv58uUpW7asXvF27twZOzs7duzYoV2XlJTEN998Q+/evbXrAgMDCQkJYeDAgYSEhODk5IS/vz/379/Xqx5D/N///R9Tpkyhe/fuhIWF4erqip+fH4cOHcr3MaOjo3FxccnXvitXrqRp06Z4enqycOFC1q5dy9y5czlz5gzbtm3TlhsxYgRt2rTh/fffJzExkddee40///xTu12fNpwwYQJz5syhU6dOLFmyBEtLSzp37szPP/8MwOjRo9m0aRP//e9/gYxnSDZt2sSmTZsMPq+pU6cyY8YMfHx8CA4OJjY2Fm9vb06dOqVTLiwsjLCwMN566y369+/Pli1bCA0NNXob6hNPr169iIiIYOzYsUyfPp13331X2zaZCuP6yYm+bZgbQ97TvK4xY9YFULlyZe2HMiGMShFCCBNw+fJlZdCgQYqZmZmiVquVqVOnKunp6YqiKMqhQ4cUINtXuXLltMf466+/FEAJDQ1VFEVRGjVqpLRu3Vq7PfM4H3zwgXLv3j3l0qVLSmhoqGJhYaG8/fbbBsXbp08fxcvLS7u8e/duBVD++usv7br//Oc/SnBwsHb53r17CqDs3r07y/HWrVunZPcr/erVqwqgHDp0SGf94MGDlXbt2imKoigPHz5UrK2tldmzZyv37t1T7t27p9y5c0dxcXFR+vbta9B5Pc3KykpJSkrKcfu8efMUNze3LOvd3NwUX19fRVEUZdWqVQqgnDx5UlEURXFxcVHmzZunfS/Gjh2r3e/vv/9WLCwslNGjR2vX5dWG58+fV1QqlTJ9+nRtmfj4eMXa2lqZOHGiTlyZdV69elX/RnjKpUuXFLVarUyePFm7LjY2VnFxcVG8vb0VRfn3/XJwcFBu3rypLefh4aFtE33o04b6xHPy5EkFUBYuXKgtc+TIEQVQBg8erCiK4ddPTteqPgxpw9yu+Uy5vaf6XGPGqutpM2bMUBYtWpRrGSHyI+t0CkII8Rx64YUX2LhxI7Nnz2bMmDGEhIRgbW3NO++8oy0zdepUOnfurF0ODg7W6bHM7NV/8cUXuX//Ps2aNWPr1q08efKEMmXKaMtNmzaNadOmaZd79erFzJkzDYq3d+/eBAQEcOfOHSpVqsSOHTtwd3enbt262jIbNmwgPT2dEydOcPLkSbZv3w5g9J7+Y8eOkZSUxDvvvKPTXgDnzp3L93ErVqxIdHQ0bm5uBu/btGlTIGPoVHbLmQICArT/r1KlCi1atODkyZPadXm14aFDh1AUhcGDB2v3sbW1LZTnMw4ePIhGo2H48OHadfb29vTv35+wsDCdOkePHo2rq6t2uX79+ty4ccOg+vJqQ33iOXbsGIDOsxlt27alevXq2uXCun6yY0gbGkte15ixRUdHU69evUI7vii9JOkXQjzXHj9+zO3bt3nhhRewtLSkXr16HDhwgLZt2xISEqIzq079+vXp2LGjdnnz5s06x9q/fz8AnTp10ln/3Xff6cwyM3nyZLp27Yq5uTk1a9bMV1Lr6+uLlZUVu3btYvjw4ezevZvx48frlNm8eTNTpkzhwYMH1K5dmw4dOhg8pj8nsbGx2v8/ePAAyBgOUqtWLZ1ytra2+a6jWrVqXLp0KV/t8+wUn9lN+QkZHyyeVq5cOZ2hF3m1Yea5V65c2eAYDZX5QePZIU9VqlQhPT2dhw8fate1aNFCp4xabfho3LzaUJ94Mmeaebadq1Spov1/YV0/2TGkDZ/19DVviLyuMWPWBXDp0iUGDRqU7/2FyImM6RdCPNf27dtH/fr1debkNzc3p1u3biQlJendK56Wlsbhw4dp27YtBw4c4MCBA+zatSvbcf0vvvgiHTt2xNvbO18JLYCdnR2vv/46O3bs4OjRo9y9e1dnPP+lS5cYOnQo3bt35/79+1y4cIHw8PB81ZWdp5OWcuXKARkPf3bs2FH7qlmzJlZWVvmu47XXXiv0bxi9ffu2zvLdu3dxcnIC9GvDzHN/dgx1cHAw06dPN2qsmV8E92zMUVFRmJmZ4ezsrF339P8Liz7xODg4AP8m9pnu3r2r/X9hXT/5jTknhozDf1pu15ix67p37x6///47Xl5e+dpfiNxI0i+EeK41atQIgG+++UZn/U8//UTZsmWz9NLl5Pjx4zx58oQePXpokxY/Pz/c3d31epg3P3r37s23337Lxo0bqV+/Pg0aNNBuO336NGlpaYwcOVKbyGzcuNHgOuzs7ADdpHb//v06SUmrVq2wtrbWeUBWo9HQrVs3pk6danCdmXr27Mm2bdsK1OuZl6fv1ty8eZNTp07x8ssvA/q1YeaMKk8/VJmSkkJYWFiWxC0zuc3v+XTs2BG1Ws3atWu16+Li4vj0009p06YNNjY2+TpufukTT+Ydh6c/vB0/fpwrV65olwvr+slvzPpc85n0eU9zu8aMXdcnn3xC586dsba2zrGMEPklw3uEEM+1hg0b4u/vz/z584mOjsbd3Z1Dhw6xe/du3nnnHb2HRWQm9k8P/8lcDgkJ4fr160aP3c/PD4DVq1czd+5cnW3169dHrVYze/Zs+vXrx08//cTWrVsBDBq3XKFCBWrXrs0HH3xA8+bNuXHjBiNGjNB5dqBs2bLMmDGD+fPnEx8fT/v27fnmm2/4888/2bNnT77Pz93dnXbt2rFgwQKCg4PzfZzcbNu2DXNzc+rXr094eDjW1tZMmjQJ0K8N69Wrx6hRo3j//fd5+PAhzZo14/PPP+f27dtZhn/Vq1eP6tWrM2XKFAYMGMDdu3fRaDTaWVnyUqtWLSZNmsSHH37I48ePeemll/j444959OhRobVPQeNp3bo1Xl5ezJ49mwcPHlChQgWCg4N1ktLCun7yG7M+13wmfd7T3K4xY9YVHR3N4sWLs0w7K4TRFPeTxEIIUVBPnjxRxowZo1SsWFGxsbFRmjRpoqxdu1a7PXPWjDVr1ujsN3jwYO3sPa1bt1YqVaqU5dh79+5VAGX16tXa44SHhxstdj8/PwVQzpw5k2Xb+vXrlRdeeEGxsrJSWrZsqRw8eFBxcXFRevbsmaVsbjOiHD9+XGnSpIlibW2tuLu7K3v27Ml2dpGwsDCldu3airW1tdK0aVNlx44dBT6/q1evKk5OTsrevXuzbMtt9p558+YpipL1vDK3Zb4XX3zxhdKkSRPF0tJSad68ufLjjz/qHEufNkxLS1MWLFiguLq6KnZ2doqXl5fy/fffZ3s+P//8s/Lyyy8rVlZWStmyZXVmBtKHRqNRFi1apFSrVk2xtLRUvLy8lKNHj2q3Z84Gc+DAAZ39snu/cqNPG+oTj6Ioyv3795WAgADFzs5OKVeunBIUFKS0a9dOO3tPJn2vn4LM3qNvzPpe84qS83uq7zVmjLqSk5OVdu3aKRMmTMh3uwiRF5WiKEoxfd4QQghRCuzcuZMhQ4Zw7do1HB0djXLMw4cP4+Pjw9WrV7P9gi8hCqoor7GgoCC++eYbDh8+bPTnIITIJGP6hRBCFKru3bvz448/Gi3hF8LUTJo0if/973+S8ItCJT39QgghhBBCmDjp6RdCCCGEEMLESdIvhBBCCCGEiZOkXwghhBBCCBMnSb8QQgghhBAmTpJ+IYQQQgghTJwk/UIIIYQQQpg4SfqFEEIIIYQwcZL0CyGEEEIIYeL+HxrKywFYL0gLAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 800x550 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# --- 2. SHAP 特征重要性蜂巢图 (Summary Plot - Violin) ---\n",
    "print(\"--- 2. SHAP 特征重要性蜂巢图 ---\")\n",
    "shap.summary_plot(shap_values[:, :, 0], X_test,plot_type=\"violin\",show=False,max_display=10) # 这里的show=False表示不直接显示图形,这样可以继续用plt来修改元素，不然就直接输出了\n",
    "plt.title(\"SHAP Feature Importance (Violin Plot)\")\n",
    "plt.show()\n",
    "# 注意下上面几个参数，plot_type可以是bar和violin，max_display表示显示前多少个特征，默认是20个"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "DL",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
